]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
New SetModified method
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_buffer swig_types[0]
2463 #define SWIGTYPE_p_char swig_types[1]
2464 #define SWIGTYPE_p_form_ops_t swig_types[2]
2465 #define SWIGTYPE_p_int swig_types[3]
2466 #define SWIGTYPE_p_long swig_types[4]
2467 #define SWIGTYPE_p_unsigned_char swig_types[5]
2468 #define SWIGTYPE_p_unsigned_int swig_types[6]
2469 #define SWIGTYPE_p_unsigned_long swig_types[7]
2470 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2471 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2472 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2473 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2474 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2475 #define SWIGTYPE_p_wxArrayString swig_types[13]
2476 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2477 #define SWIGTYPE_p_wxBitmap swig_types[15]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2479 #define SWIGTYPE_p_wxButton swig_types[17]
2480 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2481 #define SWIGTYPE_p_wxCaret swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2484 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2485 #define SWIGTYPE_p_wxColour swig_types[23]
2486 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2487 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2488 #define SWIGTYPE_p_wxControl swig_types[26]
2489 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2490 #define SWIGTYPE_p_wxCursor swig_types[28]
2491 #define SWIGTYPE_p_wxDC swig_types[29]
2492 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2493 #define SWIGTYPE_p_wxDateTime swig_types[31]
2494 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2496 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2497 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEvent swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2500 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2501 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2502 #define SWIGTYPE_p_wxFSFile swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2504 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2505 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2506 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2507 #define SWIGTYPE_p_wxFont swig_types[45]
2508 #define SWIGTYPE_p_wxFrame swig_types[46]
2509 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2510 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2511 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2512 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2513 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2514 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2515 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2516 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2517 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2518 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2519 #define SWIGTYPE_p_wxImage swig_types[57]
2520 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2521 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2522 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2523 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2524 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2525 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2526 #define SWIGTYPE_p_wxInputStream swig_types[64]
2527 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2528 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2529 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2530 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2531 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2532 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2533 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2534 #define SWIGTYPE_p_wxMenu swig_types[72]
2535 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2536 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2537 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2538 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2539 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2540 #define SWIGTYPE_p_wxMouseEvent swig_types[78]
2541 #define SWIGTYPE_p_wxMoveEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[80]
2543 #define SWIGTYPE_p_wxNcPaintEvent swig_types[81]
2544 #define SWIGTYPE_p_wxNotifyEvent swig_types[82]
2545 #define SWIGTYPE_p_wxObject swig_types[83]
2546 #define SWIGTYPE_p_wxOutputStream swig_types[84]
2547 #define SWIGTYPE_p_wxPCXHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPNGHandler swig_types[86]
2549 #define SWIGTYPE_p_wxPNMHandler swig_types[87]
2550 #define SWIGTYPE_p_wxPaintEvent swig_types[88]
2551 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[89]
2552 #define SWIGTYPE_p_wxPaperSize swig_types[90]
2553 #define SWIGTYPE_p_wxPoint swig_types[91]
2554 #define SWIGTYPE_p_wxPoint2D swig_types[92]
2555 #define SWIGTYPE_p_wxPropagateOnce swig_types[93]
2556 #define SWIGTYPE_p_wxPropagationDisabler swig_types[94]
2557 #define SWIGTYPE_p_wxPyApp swig_types[95]
2558 #define SWIGTYPE_p_wxPyCommandEvent swig_types[96]
2559 #define SWIGTYPE_p_wxPyDropTarget swig_types[97]
2560 #define SWIGTYPE_p_wxPyEvent swig_types[98]
2561 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[99]
2562 #define SWIGTYPE_p_wxPyImageHandler swig_types[100]
2563 #define SWIGTYPE_p_wxPyInputStream swig_types[101]
2564 #define SWIGTYPE_p_wxPySizer swig_types[102]
2565 #define SWIGTYPE_p_wxPyValidator swig_types[103]
2566 #define SWIGTYPE_p_wxQuantize swig_types[104]
2567 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[105]
2568 #define SWIGTYPE_p_wxRealPoint swig_types[106]
2569 #define SWIGTYPE_p_wxRect swig_types[107]
2570 #define SWIGTYPE_p_wxRegion swig_types[108]
2571 #define SWIGTYPE_p_wxScrollEvent swig_types[109]
2572 #define SWIGTYPE_p_wxScrollWinEvent swig_types[110]
2573 #define SWIGTYPE_p_wxSetCursorEvent swig_types[111]
2574 #define SWIGTYPE_p_wxShowEvent swig_types[112]
2575 #define SWIGTYPE_p_wxSize swig_types[113]
2576 #define SWIGTYPE_p_wxSizeEvent swig_types[114]
2577 #define SWIGTYPE_p_wxSizer swig_types[115]
2578 #define SWIGTYPE_p_wxSizerItem swig_types[116]
2579 #define SWIGTYPE_p_wxStaticBox swig_types[117]
2580 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[118]
2581 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[119]
2582 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[120]
2583 #define SWIGTYPE_p_wxTIFFHandler swig_types[121]
2584 #define SWIGTYPE_p_wxToolTip swig_types[122]
2585 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[123]
2586 #define SWIGTYPE_p_wxValidator swig_types[124]
2587 #define SWIGTYPE_p_wxVisualAttributes swig_types[125]
2588 #define SWIGTYPE_p_wxWindow swig_types[126]
2589 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[127]
2590 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[128]
2591 #define SWIGTYPE_p_wxXPMHandler swig_types[129]
2592 #define SWIGTYPE_p_wxZipFSHandler swig_types[130]
2593 static swig_type_info *swig_types[132];
2594 static swig_module_info swig_module = {swig_types, 131, 0, 0, 0, 0};
2595 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2596 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2597
2598 /* -------- TYPES TABLE (END) -------- */
2599
2600 #if (PY_VERSION_HEX <= 0x02000000)
2601 # if !defined(SWIG_PYTHON_CLASSIC)
2602 # error "This python version requires to use swig with the '-classic' option"
2603 # endif
2604 #endif
2605 #if (PY_VERSION_HEX <= 0x02020000)
2606 # error "This python version requires to use swig with the '-nomodern' option"
2607 #endif
2608 #if (PY_VERSION_HEX <= 0x02020000)
2609 # error "This python version requires to use swig with the '-nomodernargs' option"
2610 #endif
2611 #ifndef METH_O
2612 # error "This python version requires to use swig with the '-nofastunpack' option"
2613 #endif
2614
2615 /*-----------------------------------------------
2616 @(target):= _core_.so
2617 ------------------------------------------------*/
2618 #define SWIG_init init_core_
2619
2620 #define SWIG_name "_core_"
2621
2622 #define SWIGVERSION 0x010329
2623
2624
2625 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2626 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2627
2628
2629 #include <stdexcept>
2630
2631
2632 namespace swig {
2633 class PyObject_ptr {
2634 protected:
2635 PyObject *_obj;
2636
2637 public:
2638 PyObject_ptr() :_obj(0)
2639 {
2640 }
2641
2642 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2643 {
2644 Py_XINCREF(_obj);
2645 }
2646
2647 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2648 {
2649 if (initial_ref) Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr & operator=(const PyObject_ptr& item)
2653 {
2654 Py_XINCREF(item._obj);
2655 Py_XDECREF(_obj);
2656 _obj = item._obj;
2657 return *this;
2658 }
2659
2660 ~PyObject_ptr()
2661 {
2662 Py_XDECREF(_obj);
2663 }
2664
2665 operator PyObject *() const
2666 {
2667 return _obj;
2668 }
2669
2670 PyObject *operator->() const
2671 {
2672 return _obj;
2673 }
2674 };
2675 }
2676
2677
2678 namespace swig {
2679 struct PyObject_var : PyObject_ptr {
2680 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2681
2682 PyObject_var & operator = (PyObject* obj)
2683 {
2684 Py_XDECREF(_obj);
2685 _obj = obj;
2686 return *this;
2687 }
2688 };
2689 }
2690
2691
2692 #include "wx/wxPython/wxPython_int.h"
2693 #include "wx/wxPython/pyclasses.h"
2694 #include "wx/wxPython/twoitem.h"
2695
2696
2697 #ifndef wxPyUSE_EXPORT
2698 // Helper functions for dealing with SWIG objects and such. These are
2699 // located here so they know about the SWIG types and functions declared
2700 // in the wrapper code.
2701
2702 #include <wx/hashmap.h>
2703 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2704
2705
2706 // Maintains a hashmap of className to swig_type_info pointers. Given the
2707 // name of a class either looks up the type info in the cache, or scans the
2708 // SWIG tables for it.
2709 extern PyObject* wxPyPtrTypeMap;
2710 static
2711 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2712
2713 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2714
2715 if (typeInfoCache == NULL)
2716 typeInfoCache = new wxPyTypeInfoHashMap;
2717
2718 wxString name(className);
2719 swig_type_info* swigType = (*typeInfoCache)[name];
2720
2721 if (! swigType) {
2722 // it wasn't in the cache, so look it up from SWIG
2723 name.Append(wxT(" *"));
2724 swigType = SWIG_TypeQuery(name.mb_str());
2725
2726 // if it still wasn't found, try looking for a mapped name
2727 if (!swigType) {
2728 PyObject* item;
2729 name = className;
2730
2731 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2732 (char*)(const char*)name.mbc_str())) != NULL) {
2733 name = wxString(PyString_AsString(item), *wxConvCurrent);
2734 name.Append(wxT(" *"));
2735 swigType = SWIG_TypeQuery(name.mb_str());
2736 }
2737 }
2738 if (swigType) {
2739 // and add it to the map if found
2740 (*typeInfoCache)[className] = swigType;
2741 }
2742 }
2743 return swigType;
2744 }
2745
2746
2747 // Check if a class name is a type known to SWIG
2748 bool wxPyCheckSwigType(const wxChar* className) {
2749
2750 swig_type_info* swigType = wxPyFindSwigType(className);
2751 return swigType != NULL;
2752 }
2753
2754
2755 // Given a pointer to a C++ object and a class name, construct a Python proxy
2756 // object for it.
2757 PyObject* wxPyConstructObject(void* ptr,
2758 const wxChar* className,
2759 int setThisOwn) {
2760
2761 swig_type_info* swigType = wxPyFindSwigType(className);
2762 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2763
2764 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2765 }
2766
2767
2768 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2769 // Ensures that the proxy object is of the specified (or derived) type. If
2770 // not able to perform the conversion then a Python exception is set and the
2771 // error should be handled properly in the caller. Returns True on success.
2772 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2773 const wxChar* className) {
2774
2775 swig_type_info* swigType = wxPyFindSwigType(className);
2776 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2777
2778 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2779 }
2780
2781
2782
2783 // Make a SWIGified pointer object suitable for a .this attribute
2784 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2785
2786 PyObject* robj = NULL;
2787
2788 swig_type_info* swigType = wxPyFindSwigType(className);
2789 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2790
2791 robj = PySwigObject_New(ptr, swigType, 0);
2792 return robj;
2793 }
2794
2795
2796 // Python's PyInstance_Check does not return True for instances of new-style
2797 // classes. This should get close enough for both new and old classes but I
2798 // should re-evaluate the need for doing instance checks...
2799 bool wxPyInstance_Check(PyObject* obj) {
2800 return PyObject_HasAttrString(obj, "__class__") != 0;
2801 }
2802
2803
2804 // This one checks if the object is an instance of a SWIG proxy class (it has
2805 // a .this attribute, and the .this attribute is a PySwigObject.)
2806 bool wxPySwigInstance_Check(PyObject* obj) {
2807 static PyObject* this_str = NULL;
2808 if (this_str == NULL)
2809 this_str = PyString_FromString("this");
2810
2811 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2812 if (this_attr) {
2813 bool retval = (PySwigObject_Check(this_attr) != 0);
2814 Py_DECREF(this_attr);
2815 return retval;
2816 }
2817
2818 PyErr_Clear();
2819 return false;
2820 }
2821
2822
2823 // Export a C API in a struct. Other modules will be able to load this from
2824 // the wx._core_ module and will then have safe access to these functions,
2825 // even if they are located in another shared library.
2826 static wxPyCoreAPI API = {
2827
2828 wxPyCheckSwigType,
2829 wxPyConstructObject,
2830 wxPyConvertSwigPtr,
2831 wxPyMakeSwigPtr,
2832
2833 wxPyBeginAllowThreads,
2834 wxPyEndAllowThreads,
2835 wxPyBeginBlockThreads,
2836 wxPyEndBlockThreads,
2837
2838 wxPy_ConvertList,
2839
2840 wxString_in_helper,
2841 Py2wxString,
2842 wx2PyString,
2843
2844 byte_LIST_helper,
2845 int_LIST_helper,
2846 long_LIST_helper,
2847 string_LIST_helper,
2848 wxPoint_LIST_helper,
2849 wxBitmap_LIST_helper,
2850 wxString_LIST_helper,
2851 wxAcceleratorEntry_LIST_helper,
2852
2853 wxSize_helper,
2854 wxPoint_helper,
2855 wxRealPoint_helper,
2856 wxRect_helper,
2857 wxColour_helper,
2858 wxPoint2D_helper,
2859
2860 wxPySimple_typecheck,
2861 wxColour_typecheck,
2862
2863 wxPyCBH_setCallbackInfo,
2864 wxPyCBH_findCallback,
2865 wxPyCBH_callCallback,
2866 wxPyCBH_callCallbackObj,
2867 wxPyCBH_delete,
2868
2869 wxPyMake_wxObject,
2870 wxPyMake_wxSizer,
2871 wxPyPtrTypeMap_Add,
2872 wxPy2int_seq_helper,
2873 wxPy4int_seq_helper,
2874 wxArrayString2PyList_helper,
2875 wxArrayInt2PyList_helper,
2876
2877 wxPyClientData_dtor,
2878 wxPyUserData_dtor,
2879 wxPyOORClientData_dtor,
2880
2881 wxPyCBInputStream_create,
2882 wxPyCBInputStream_copy,
2883
2884 wxPyInstance_Check,
2885 wxPySwigInstance_Check,
2886
2887 wxPyCheckForApp
2888
2889 };
2890
2891 #endif
2892
2893
2894 #if !WXWIN_COMPATIBILITY_2_4
2895 #define wxHIDE_READONLY 0
2896 #endif
2897
2898
2899 #define SWIG_From_long PyInt_FromLong
2900
2901
2902 SWIGINTERNINLINE PyObject *
2903 SWIG_From_int (int value)
2904 {
2905 return SWIG_From_long (value);
2906 }
2907
2908 static const wxString wxPyEmptyString(wxEmptyString);
2909 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2910 return self->GetClassInfo()->GetClassName();
2911 }
2912 SWIGINTERN void wxObject_Destroy(wxObject *self){
2913 delete self;
2914 }
2915
2916 #ifndef __WXMAC__
2917 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2918 #endif
2919
2920
2921 #include <limits.h>
2922 #ifndef LLONG_MIN
2923 # define LLONG_MIN LONG_LONG_MIN
2924 #endif
2925 #ifndef LLONG_MAX
2926 # define LLONG_MAX LONG_LONG_MAX
2927 #endif
2928 #ifndef ULLONG_MAX
2929 # define ULLONG_MAX ULONG_LONG_MAX
2930 #endif
2931
2932
2933 SWIGINTERN int
2934 SWIG_AsVal_long (PyObject* obj, long* val)
2935 {
2936 if (PyNumber_Check(obj)) {
2937 if (val) *val = PyInt_AsLong(obj);
2938 return SWIG_OK;
2939 }
2940 return SWIG_TypeError;
2941 }
2942
2943
2944 SWIGINTERN int
2945 SWIG_AsVal_int (PyObject * obj, int *val)
2946 {
2947 long v;
2948 int res = SWIG_AsVal_long (obj, &v);
2949 if (SWIG_IsOK(res)) {
2950 if ((v < INT_MIN || v > INT_MAX)) {
2951 return SWIG_OverflowError;
2952 } else {
2953 if (val) *val = static_cast< int >(v);
2954 }
2955 }
2956 return res;
2957 }
2958
2959 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2960 wxSize temp, *obj = &temp;
2961 if ( other == Py_None ) return false;
2962 if ( ! wxSize_helper(other, &obj) ) {
2963 PyErr_Clear();
2964 return false;
2965 }
2966 return self->operator==(*obj);
2967 }
2968 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2969 wxSize temp, *obj = &temp;
2970 if ( other == Py_None ) return true;
2971 if ( ! wxSize_helper(other, &obj)) {
2972 PyErr_Clear();
2973 return true;
2974 }
2975 return self->operator!=(*obj);
2976 }
2977 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2978 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2979 PyObject* tup = PyTuple_New(2);
2980 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2981 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2982 wxPyEndBlockThreads(blocked);
2983 return tup;
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 #define SWIG_From_double PyFloat_FromDouble
2998
2999 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3000 wxRealPoint temp, *obj = &temp;
3001 if ( other == Py_None ) return false;
3002 if ( ! wxRealPoint_helper(other, &obj) ) {
3003 PyErr_Clear();
3004 return false;
3005 }
3006 return self->operator==(*obj);
3007 }
3008 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3009 wxRealPoint temp, *obj = &temp;
3010 if ( other == Py_None ) return true;
3011 if ( ! wxRealPoint_helper(other, &obj)) {
3012 PyErr_Clear();
3013 return true;
3014 }
3015 return self->operator!=(*obj);
3016 }
3017 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3018 self->x = x;
3019 self->y = y;
3020 }
3021 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3022 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3023 PyObject* tup = PyTuple_New(2);
3024 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3025 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3026 wxPyEndBlockThreads(blocked);
3027 return tup;
3028 }
3029 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3030 wxPoint temp, *obj = &temp;
3031 if ( other == Py_None ) return false;
3032 if ( ! wxPoint_helper(other, &obj) ) {
3033 PyErr_Clear();
3034 return false;
3035 }
3036 return self->operator==(*obj);
3037 }
3038 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3039 wxPoint temp, *obj = &temp;
3040 if ( other == Py_None ) return true;
3041 if ( ! wxPoint_helper(other, &obj)) {
3042 PyErr_Clear();
3043 return true;
3044 }
3045 return self->operator!=(*obj);
3046 }
3047 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3048 self->x = x;
3049 self->y = y;
3050 }
3051 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3052 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3053 PyObject* tup = PyTuple_New(2);
3054 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3055 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3056 wxPyEndBlockThreads(blocked);
3057 return tup;
3058 }
3059 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3060 wxRect temp, *obj = &temp;
3061 if ( other == Py_None ) return false;
3062 if ( ! wxRect_helper(other, &obj) ) {
3063 PyErr_Clear();
3064 return false;
3065 }
3066 return self->operator==(*obj);
3067 }
3068 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3069 wxRect temp, *obj = &temp;
3070 if ( other == Py_None ) return true;
3071 if ( ! wxRect_helper(other, &obj)) {
3072 PyErr_Clear();
3073 return true;
3074 }
3075 return self->operator!=(*obj);
3076 }
3077 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3078 self->x = x;
3079 self->y = y;
3080 self->width = width;
3081 self->height = height;
3082 }
3083 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3084 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3085 PyObject* tup = PyTuple_New(4);
3086 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3087 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3088 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3089 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3090 wxPyEndBlockThreads(blocked);
3091 return tup;
3092 }
3093
3094 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3095 wxRegion reg1(*r1);
3096 wxRegion reg2(*r2);
3097 wxRect dest(0,0,0,0);
3098 PyObject* obj;
3099
3100 reg1.Intersect(reg2);
3101 dest = reg1.GetBox();
3102
3103 if (dest != wxRect(0,0,0,0)) {
3104 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3105 wxRect* newRect = new wxRect(dest);
3106 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3107 wxPyEndBlockThreads(blocked);
3108 return obj;
3109 }
3110 Py_INCREF(Py_None);
3111 return Py_None;
3112 }
3113
3114 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3115 wxPoint2D temp, *obj = &temp;
3116 if ( other == Py_None ) return false;
3117 if ( ! wxPoint2D_helper(other, &obj) ) {
3118 PyErr_Clear();
3119 return false;
3120 }
3121 return self->operator==(*obj);
3122 }
3123 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3124 wxPoint2D temp, *obj = &temp;
3125 if ( other == Py_None ) return true;
3126 if ( ! wxPoint2D_helper(other, &obj)) {
3127 PyErr_Clear();
3128 return true;
3129 }
3130 return self->operator!=(*obj);
3131 }
3132 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3133 self->m_x = x;
3134 self->m_y = y;
3135 }
3136 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3137 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3138 PyObject* tup = PyTuple_New(2);
3139 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3140 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3141 wxPyEndBlockThreads(blocked);
3142 return tup;
3143 }
3144
3145 #include "wx/wxPython/pyistream.h"
3146
3147 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3148 wxInputStream* wxis = wxPyCBInputStream::create(p);
3149 if (wxis)
3150 return new wxPyInputStream(wxis);
3151 else
3152 return NULL;
3153 }
3154
3155 SWIGINTERN swig_type_info*
3156 SWIG_pchar_descriptor()
3157 {
3158 static int init = 0;
3159 static swig_type_info* info = 0;
3160 if (!init) {
3161 info = SWIG_TypeQuery("_p_char");
3162 init = 1;
3163 }
3164 return info;
3165 }
3166
3167
3168 SWIGINTERNINLINE PyObject *
3169 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3170 {
3171 if (carray) {
3172 if (size > INT_MAX) {
3173 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3174 return pchar_descriptor ?
3175 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3176 } else {
3177 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3178 }
3179 } else {
3180 return SWIG_Py_Void();
3181 }
3182 }
3183
3184
3185 SWIGINTERNINLINE PyObject *
3186 SWIG_From_char (char c)
3187 {
3188 return SWIG_FromCharPtrAndSize(&c,1);
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject*
3193 SWIG_From_unsigned_SS_long (unsigned long value)
3194 {
3195 return (value > LONG_MAX) ?
3196 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3197 }
3198
3199
3200 SWIGINTERNINLINE PyObject *
3201 SWIG_From_size_t (size_t value)
3202 {
3203 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3204 }
3205
3206
3207 SWIGINTERN int
3208 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3209 {
3210 if (PyString_Check(obj)) {
3211 char *cstr; int len;
3212 PyString_AsStringAndSize(obj, &cstr, &len);
3213 if (cptr) {
3214 if (alloc) {
3215 /*
3216 In python the user should not be able to modify the inner
3217 string representation. To warranty that, if you define
3218 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3219 buffer is always returned.
3220
3221 The default behavior is just to return the pointer value,
3222 so, be careful.
3223 */
3224 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3225 if (*alloc != SWIG_OLDOBJ)
3226 #else
3227 if (*alloc == SWIG_NEWOBJ)
3228 #endif
3229 {
3230 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3231 *alloc = SWIG_NEWOBJ;
3232 }
3233 else {
3234 *cptr = cstr;
3235 *alloc = SWIG_OLDOBJ;
3236 }
3237 } else {
3238 *cptr = PyString_AsString(obj);
3239 }
3240 }
3241 if (psize) *psize = len + 1;
3242 return SWIG_OK;
3243 } else {
3244 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3245 if (pchar_descriptor) {
3246 void* vptr = 0;
3247 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3248 if (cptr) *cptr = (char *) vptr;
3249 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3250 if (alloc) *alloc = SWIG_OLDOBJ;
3251 return SWIG_OK;
3252 }
3253 }
3254 }
3255 return SWIG_TypeError;
3256 }
3257
3258
3259 SWIGINTERN int
3260 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3261 {
3262 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3263 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3264 if (SWIG_IsOK(res)) {
3265 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3266 if (csize <= size) {
3267 if (val) {
3268 if (csize) memcpy(val, cptr, csize*sizeof(char));
3269 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3270 }
3271 if (alloc == SWIG_NEWOBJ) {
3272 delete[] cptr;
3273 res = SWIG_DelNewMask(res);
3274 }
3275 return res;
3276 }
3277 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsVal_char (PyObject * obj, char *val)
3285 {
3286 int res = SWIG_AsCharArray(obj, val, 1);
3287 if (!SWIG_IsOK(res)) {
3288 long v;
3289 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3290 if (SWIG_IsOK(res)) {
3291 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3292 if (val) *val = static_cast< char >(v);
3293 } else {
3294 res = SWIG_OverflowError;
3295 }
3296 }
3297 }
3298 return res;
3299 }
3300
3301 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3302 // We use only strings for the streams, not unicode
3303 PyObject* str = PyObject_Str(obj);
3304 if (! str) {
3305 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3306 return;
3307 }
3308 self->Write(PyString_AS_STRING(str),
3309 PyString_GET_SIZE(str));
3310 Py_DECREF(str);
3311 }
3312
3313 #include "wx/wxPython/pyistream.h"
3314
3315
3316 class wxPyFileSystemHandler : public wxFileSystemHandler
3317 {
3318 public:
3319 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3320
3321 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3322 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3323 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3324 DEC_PYCALLBACK_STRING__pure(FindNext);
3325
3326 wxString GetProtocol(const wxString& location) {
3327 return wxFileSystemHandler::GetProtocol(location);
3328 }
3329
3330 wxString GetLeftLocation(const wxString& location) {
3331 return wxFileSystemHandler::GetLeftLocation(location);
3332 }
3333
3334 wxString GetAnchor(const wxString& location) {
3335 return wxFileSystemHandler::GetAnchor(location);
3336 }
3337
3338 wxString GetRightLocation(const wxString& location) {
3339 return wxFileSystemHandler::GetRightLocation(location);
3340 }
3341
3342 wxString GetMimeTypeFromExt(const wxString& location) {
3343 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3344 }
3345
3346 PYPRIVATE;
3347 };
3348
3349
3350 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3351 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3352 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3353 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3354
3355
3356 SWIGINTERN int
3357 SWIG_AsVal_bool (PyObject *obj, bool *val)
3358 {
3359 if (obj == Py_True) {
3360 if (val) *val = true;
3361 return SWIG_OK;
3362 } else if (obj == Py_False) {
3363 if (val) *val = false;
3364 return SWIG_OK;
3365 } else {
3366 long v = 0;
3367 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3368 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3369 return res;
3370 }
3371 }
3372
3373 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3374 wxFileName fname = wxFileSystem::URLToFileName(url);
3375 return fname.GetFullPath();
3376 }
3377
3378 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3379 wxImage& image,
3380 long type) {
3381 wxMemoryFSHandler::AddFile(filename, image, type);
3382 }
3383
3384 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3385 const wxBitmap& bitmap,
3386 long type) {
3387 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3388 }
3389
3390 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3391 PyObject* data) {
3392 if (! PyString_Check(data)) {
3393 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3394 "Expected string object"));
3395 return;
3396 }
3397
3398 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3399 void* ptr = (void*)PyString_AsString(data);
3400 size_t size = PyString_Size(data);
3401 wxPyEndBlockThreads(blocked);
3402
3403 wxMemoryFSHandler::AddFile(filename, ptr, size);
3404 }
3405
3406
3407 #include "wx/wxPython/pyistream.h"
3408
3409
3410 SWIGINTERN int
3411 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3412 {
3413 long v = 0;
3414 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3415 return SWIG_TypeError;
3416 }
3417 else if (val)
3418 *val = (unsigned long)v;
3419 return SWIG_OK;
3420 }
3421
3422
3423 SWIGINTERN int
3424 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3425 {
3426 unsigned long v;
3427 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3428 if (SWIG_IsOK(res)) {
3429 if ((v > UCHAR_MAX)) {
3430 return SWIG_OverflowError;
3431 } else {
3432 if (val) *val = static_cast< unsigned char >(v);
3433 }
3434 }
3435 return res;
3436 }
3437
3438
3439 SWIGINTERNINLINE PyObject *
3440 SWIG_From_unsigned_SS_char (unsigned char value)
3441 {
3442 return SWIG_From_unsigned_SS_long (value);
3443 }
3444
3445 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3446 wxImageHistogramEntry e = (*self)[key];
3447 return e.value;
3448 }
3449 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3450 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3451 wxImageHistogramEntry e = (*self)[key];
3452 return e.value;
3453 }
3454 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3455 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3456 colour.Green(),
3457 colour.Blue());
3458 wxImageHistogramEntry e = (*self)[key];
3459 return e.value;
3460 }
3461
3462 typedef unsigned char* buffer;
3463
3464
3465 // Pull the nested class out to the top level for SWIG's sake
3466 #define wxImage_RGBValue wxImage::RGBValue
3467 #define wxImage_HSVValue wxImage::HSVValue
3468
3469 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3470 if (width > 0 && height > 0)
3471 return new wxImage(width, height, clear);
3472 else
3473 return new wxImage;
3474 }
3475 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3476 return new wxImage(bitmap.ConvertToImage());
3477 }
3478 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3479 if (DATASIZE != width*height*3) {
3480 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3481 return NULL;
3482 }
3483
3484 // Copy the source data so the wxImage can clean it up later
3485 buffer copy = (buffer)malloc(DATASIZE);
3486 if (copy == NULL) {
3487 wxPyBLOCK_THREADS(PyErr_NoMemory());
3488 return NULL;
3489 }
3490 memcpy(copy, data, DATASIZE);
3491 return new wxImage(width, height, copy, false);
3492 }
3493 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3494 if (DATASIZE != width*height*3) {
3495 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3496 return NULL;
3497 }
3498 if (ALPHASIZE != width*height) {
3499 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3500 return NULL;
3501 }
3502
3503 // Copy the source data so the wxImage can clean it up later
3504 buffer dcopy = (buffer)malloc(DATASIZE);
3505 if (dcopy == NULL) {
3506 wxPyBLOCK_THREADS(PyErr_NoMemory());
3507 return NULL;
3508 }
3509 memcpy(dcopy, data, DATASIZE);
3510
3511 buffer acopy = (buffer)malloc(ALPHASIZE);
3512 if (acopy == NULL) {
3513 wxPyBLOCK_THREADS(PyErr_NoMemory());
3514 return NULL;
3515 }
3516 memcpy(acopy, alpha, ALPHASIZE);
3517
3518 return new wxImage(width, height, dcopy, acopy, false);
3519 }
3520 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3521 wxSize size(self->GetWidth(), self->GetHeight());
3522 return size;
3523 }
3524 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3525 buffer data = self->GetData();
3526 int len = self->GetWidth() * self->GetHeight() * 3;
3527 PyObject* rv;
3528 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3529 return rv;
3530 }
3531 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3532 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3533 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3534 return;
3535 }
3536 buffer copy = (buffer)malloc(DATASIZE);
3537 if (copy == NULL) {
3538 wxPyBLOCK_THREADS(PyErr_NoMemory());
3539 return;
3540 }
3541 memcpy(copy, data, DATASIZE);
3542 self->SetData(copy, false);
3543 // wxImage takes ownership of copy...
3544 }
3545 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3546 buffer data = self->GetData();
3547 int len = self->GetWidth() * self->GetHeight() * 3;
3548 PyObject* rv;
3549 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3550 return rv;
3551 }
3552 SWIGINTERN void wxImage_SetDataBuffer(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 self->SetData(data, true);
3558 }
3559 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3560 buffer data = self->GetAlpha();
3561 if (! data) {
3562 RETURN_NONE();
3563 } else {
3564 int len = self->GetWidth() * self->GetHeight();
3565 PyObject* rv;
3566 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3567 return rv;
3568 }
3569 }
3570 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3571 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3572 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3573 return;
3574 }
3575 buffer acopy = (buffer)malloc(ALPHASIZE);
3576 if (acopy == NULL) {
3577 wxPyBLOCK_THREADS(PyErr_NoMemory());
3578 return;
3579 }
3580 memcpy(acopy, alpha, ALPHASIZE);
3581 self->SetAlpha(acopy, false);
3582 // wxImage takes ownership of acopy...
3583 }
3584 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3585 buffer data = self->GetAlpha();
3586 int len = self->GetWidth() * self->GetHeight();
3587 PyObject* rv;
3588 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3589 return rv;
3590 }
3591 SWIGINTERN void wxImage_SetAlphaBuffer(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 self->SetAlpha(alpha, true);
3597 }
3598 SWIGINTERN PyObject *wxImage_GetHandlers(){
3599 wxList& list = wxImage::GetHandlers();
3600 return wxPy_ConvertList(&list);
3601 }
3602 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3603 wxBitmap bitmap(*self, depth);
3604 return bitmap;
3605 }
3606 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3607 wxImage mono = self->ConvertToMono( red, green, blue );
3608 wxBitmap bitmap( mono, 1 );
3609 return bitmap;
3610 }
3611 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3612 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3613 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3614 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3615 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3616 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3617 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3618 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3619 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3620 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3621 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3622 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3623 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3624 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3625 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3626
3627 #include <wx/quantize.h>
3628
3629 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3630 return wxQuantize::Quantize(src, dest,
3631 //NULL, // palette
3632 desiredNoColours,
3633 NULL, // eightBitData
3634 flags);
3635 }
3636 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3637 if (PyCallable_Check(func)) {
3638 self->Connect(id, lastId, eventType,
3639 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3640 new wxPyCallback(func));
3641 }
3642 else if (func == Py_None) {
3643 self->Disconnect(id, lastId, eventType,
3644 (wxObjectEventFunction)
3645 &wxPyCallback::EventThunker);
3646 }
3647 else {
3648 wxPyBLOCK_THREADS(
3649 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3650 }
3651 }
3652 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3653 return self->Disconnect(id, lastId, eventType,
3654 (wxObjectEventFunction)
3655 &wxPyCallback::EventThunker);
3656 }
3657 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3658 if (_self && _self != Py_None) {
3659 self->SetClientObject(new wxPyOORClientData(_self, incref));
3660 }
3661 else {
3662 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3663 if (data) {
3664 self->SetClientObject(NULL); // This will delete it too
3665 }
3666 }
3667 }
3668
3669 #if ! wxUSE_HOTKEY
3670 #define wxEVT_HOTKEY -9999
3671 #endif
3672
3673 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3674 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3675 if (data) {
3676 Py_INCREF(data->m_obj);
3677 return data->m_obj;
3678 } else {
3679 Py_INCREF(Py_None);
3680 return Py_None;
3681 }
3682 }
3683 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3684 wxPyClientData* data = new wxPyClientData(clientData);
3685 self->SetClientObject(data);
3686 }
3687 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3688 #if wxUSE_UNICODE
3689 return self->GetUnicodeKey();
3690 #else
3691 return 0;
3692 #endif
3693 }
3694 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3695 #if wxUSE_UNICODE
3696 self->m_uniChar = uniChar;
3697 #endif
3698 }
3699
3700 SWIGINTERNINLINE PyObject *
3701 SWIG_From_unsigned_SS_int (unsigned int value)
3702 {
3703 return SWIG_From_unsigned_SS_long (value);
3704 }
3705
3706
3707 SWIGINTERN int
3708 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3709 {
3710 unsigned long v;
3711 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3712 if (SWIG_IsOK(res)) {
3713 if ((v > UINT_MAX)) {
3714 return SWIG_OverflowError;
3715 } else {
3716 if (val) *val = static_cast< unsigned int >(v);
3717 }
3718 }
3719 return res;
3720 }
3721
3722 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3723 self->m_size = size;
3724 }
3725 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3726 int count = self->GetNumberOfFiles();
3727 wxString* files = self->GetFiles();
3728 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3729 PyObject* list = PyList_New(count);
3730
3731 if (!list) {
3732 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3733 wxPyEndBlockThreads(blocked);
3734 return NULL;
3735 }
3736
3737 for (int i=0; i<count; i++) {
3738 PyList_SetItem(list, i, wx2PyString(files[i]));
3739 }
3740 wxPyEndBlockThreads(blocked);
3741 return list;
3742 }
3743
3744
3745 SWIGINTERN wxPyApp *new_wxPyApp(){
3746 wxPythonApp = new wxPyApp();
3747 return wxPythonApp;
3748 }
3749 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3750
3751 void wxApp_CleanUp() {
3752 __wxPyCleanup();
3753 }
3754
3755
3756 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3757
3758
3759
3760
3761
3762 SWIGINTERNINLINE PyObject *
3763 SWIG_FromCharPtr(const char *cptr)
3764 {
3765 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3766 }
3767
3768
3769 #if 0 // #ifdef __WXMAC__
3770
3771 // A dummy class that raises an exception if used...
3772 class wxEventLoop
3773 {
3774 public:
3775 wxEventLoop() { wxPyRaiseNotImplemented(); }
3776 int Run() { return 0; }
3777 void Exit(int rc = 0) {}
3778 bool Pending() const { return false; }
3779 bool Dispatch() { return false; }
3780 bool IsRunning() const { return false; }
3781 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3782 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3783 };
3784
3785 #else
3786
3787 #include <wx/evtloop.h>
3788
3789 #endif
3790
3791
3792
3793 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3794 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3795 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3796 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3797 wxWindowList& list = self->GetChildren();
3798 return wxPy_ConvertList(&list);
3799 }
3800 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3801 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3802 #if wxUSE_HOTKEY
3803 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3804 #else
3805 return false;
3806 #endif
3807 }
3808 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3809
3810
3811
3812 return false;
3813
3814 }
3815 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3816 return wxPyGetWinHandle(self);
3817 }
3818 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3819 self->AssociateHandle((WXWidget)handle);
3820 }
3821 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3822
3823 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3824 return wxWindow::FindWindowById(id, parent);
3825 }
3826
3827 wxWindow* wxFindWindowByName( const wxString& name,
3828 const wxWindow *parent = NULL ) {
3829 return wxWindow::FindWindowByName(name, parent);
3830 }
3831
3832 wxWindow* wxFindWindowByLabel( const wxString& label,
3833 const wxWindow *parent = NULL ) {
3834 return wxWindow::FindWindowByLabel(label, parent);
3835 }
3836
3837
3838 #ifdef __WXMSW__
3839 #include <wx/msw/private.h> // to get wxGetWindowId
3840 #endif
3841
3842
3843 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3844 #ifdef __WXMSW__
3845 WXHWND hWnd = (WXHWND)_hWnd;
3846 long id = wxGetWindowId(hWnd);
3847 wxWindow* win = new wxWindow;
3848 if (parent)
3849 parent->AddChild(win);
3850 win->SetEventHandler(win);
3851 win->SetHWND(hWnd);
3852 win->SetId(id);
3853 win->SubclassWin(hWnd);
3854 win->AdoptAttributesFromHWND();
3855 win->SetupColours();
3856 return win;
3857 #else
3858 wxPyRaiseNotImplemented();
3859 return NULL;
3860 #endif
3861 }
3862
3863
3864 PyObject* GetTopLevelWindows() {
3865 return wxPy_ConvertList(&wxTopLevelWindows);
3866 }
3867
3868
3869 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3870 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3871 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3872
3873 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3874
3875
3876 SWIGINTERNINLINE int
3877 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3878 {
3879 unsigned long v;
3880 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3881 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3882 return res;
3883 }
3884
3885 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3886 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3887 wxMenuItemList& list = self->GetMenuItems();
3888 return wxPy_ConvertList(&list);
3889 }
3890 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3891 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3892 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3893 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3894 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3895 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3896 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3897 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3898 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3899 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3900 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3901 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3902 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3903 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3904 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3905 static const wxString wxPyControlNameStr(wxControlNameStr);
3906 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3907 if (clientData) {
3908 wxPyClientData* data = new wxPyClientData(clientData);
3909 return self->Append(item, data);
3910 } else
3911 return self->Append(item);
3912 }
3913 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3914 if (clientData) {
3915 wxPyClientData* data = new wxPyClientData(clientData);
3916 return self->Insert(item, pos, data);
3917 } else
3918 return self->Insert(item, pos);
3919 }
3920 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3921 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3922 if (data) {
3923 Py_INCREF(data->m_obj);
3924 return data->m_obj;
3925 } else {
3926 Py_INCREF(Py_None);
3927 return Py_None;
3928 }
3929 }
3930 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3931 wxPyClientData* data = new wxPyClientData(clientData);
3932 self->SetClientObject(n, data);
3933 }
3934
3935
3936 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3937 wxPyUserData* data = NULL;
3938 if ( userData ) {
3939 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3940 data = new wxPyUserData(userData);
3941 wxPyEndBlockThreads(blocked);
3942 }
3943 return new wxSizerItem(window, proportion, flag, border, data);
3944 }
3945 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3946 wxPyUserData* data = NULL;
3947 if ( userData ) {
3948 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3949 data = new wxPyUserData(userData);
3950 wxPyEndBlockThreads(blocked);
3951 }
3952 return new wxSizerItem(width, height, proportion, flag, border, data);
3953 }
3954 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3955 wxPyUserData* data = NULL;
3956 if ( userData ) {
3957 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3958 data = new wxPyUserData(userData);
3959 wxPyEndBlockThreads(blocked);
3960 }
3961 return new wxSizerItem(sizer, proportion, flag, border, data);
3962 }
3963
3964 #include <float.h>
3965
3966
3967 SWIGINTERN int
3968 SWIG_AsVal_float (PyObject * obj, float *val)
3969 {
3970 double v;
3971 int res = SWIG_AsVal_double (obj, &v);
3972 if (SWIG_IsOK(res)) {
3973 if ((v < -FLT_MAX || v > FLT_MAX)) {
3974 return SWIG_OverflowError;
3975 } else {
3976 if (val) *val = static_cast< float >(v);
3977 }
3978 }
3979 return res;
3980 }
3981
3982
3983 SWIGINTERNINLINE PyObject *
3984 SWIG_From_float (float value)
3985 {
3986 return SWIG_From_double (value);
3987 }
3988
3989 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3990 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3991 if (data) {
3992 Py_INCREF(data->m_obj);
3993 return data->m_obj;
3994 } else {
3995 Py_INCREF(Py_None);
3996 return Py_None;
3997 }
3998 }
3999 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4000 wxPyUserData* data = NULL;
4001 if ( userData ) {
4002 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4003 data = new wxPyUserData(userData);
4004 wxPyEndBlockThreads(blocked);
4005 }
4006 self->SetUserData(data);
4007 }
4008
4009 // Figure out the type of the sizer item
4010
4011 struct wxPySizerItemInfo {
4012 wxPySizerItemInfo()
4013 : window(NULL), sizer(NULL), gotSize(false),
4014 size(wxDefaultSize), gotPos(false), pos(-1)
4015 {}
4016
4017 wxWindow* window;
4018 wxSizer* sizer;
4019 bool gotSize;
4020 wxSize size;
4021 bool gotPos;
4022 int pos;
4023 };
4024
4025 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4026
4027 wxPySizerItemInfo info;
4028 wxSize size;
4029 wxSize* sizePtr = &size;
4030
4031 // Find out what the type of the item is
4032 // try wxWindow
4033 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4034 PyErr_Clear();
4035 info.window = NULL;
4036
4037 // try wxSizer
4038 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4039 PyErr_Clear();
4040 info.sizer = NULL;
4041
4042 // try wxSize or (w,h)
4043 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4044 info.size = *sizePtr;
4045 info.gotSize = true;
4046 }
4047
4048 // or a single int
4049 if (checkIdx && PyInt_Check(item)) {
4050 info.pos = PyInt_AsLong(item);
4051 info.gotPos = true;
4052 }
4053 }
4054 }
4055
4056 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4057 // no expected type, figure out what kind of error message to generate
4058 if ( !checkSize && !checkIdx )
4059 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4060 else if ( checkSize && !checkIdx )
4061 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4062 else if ( !checkSize && checkIdx)
4063 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4064 else
4065 // can this one happen?
4066 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4067 }
4068
4069 return info;
4070 }
4071
4072 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4073 if (!self->GetClientObject())
4074 self->SetClientObject(new wxPyOORClientData(_self));
4075 }
4076 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4077
4078 wxPyUserData* data = NULL;
4079 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4080 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4081 if ( userData && (info.window || info.sizer || info.gotSize) )
4082 data = new wxPyUserData(userData);
4083 if ( info.sizer )
4084 PyObject_SetAttrString(item,"thisown",Py_False);
4085 wxPyEndBlockThreads(blocked);
4086
4087 // Now call the real Add method if a valid item type was found
4088 if ( info.window )
4089 return self->Add(info.window, proportion, flag, border, data);
4090 else if ( info.sizer )
4091 return self->Add(info.sizer, proportion, flag, border, data);
4092 else if (info.gotSize)
4093 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4094 proportion, flag, border, data);
4095 else
4096 return NULL;
4097 }
4098 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4099
4100 wxPyUserData* data = NULL;
4101 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4102 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4103 if ( userData && (info.window || info.sizer || info.gotSize) )
4104 data = new wxPyUserData(userData);
4105 if ( info.sizer )
4106 PyObject_SetAttrString(item,"thisown",Py_False);
4107 wxPyEndBlockThreads(blocked);
4108
4109 // Now call the real Insert method if a valid item type was found
4110 if ( info.window )
4111 return self->Insert(before, info.window, proportion, flag, border, data);
4112 else if ( info.sizer )
4113 return self->Insert(before, info.sizer, proportion, flag, border, data);
4114 else if (info.gotSize)
4115 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4116 proportion, flag, border, data);
4117 else
4118 return NULL;
4119 }
4120 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4121
4122 wxPyUserData* data = NULL;
4123 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4124 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4125 if ( userData && (info.window || info.sizer || info.gotSize) )
4126 data = new wxPyUserData(userData);
4127 if ( info.sizer )
4128 PyObject_SetAttrString(item,"thisown",Py_False);
4129 wxPyEndBlockThreads(blocked);
4130
4131 // Now call the real Prepend method if a valid item type was found
4132 if ( info.window )
4133 return self->Prepend(info.window, proportion, flag, border, data);
4134 else if ( info.sizer )
4135 return self->Prepend(info.sizer, proportion, flag, border, data);
4136 else if (info.gotSize)
4137 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4138 proportion, flag, border, data);
4139 else
4140 return NULL;
4141 }
4142 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4143 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4144 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4145 wxPyEndBlockThreads(blocked);
4146 if ( info.window )
4147 return self->Remove(info.window);
4148 else if ( info.sizer )
4149 return self->Remove(info.sizer);
4150 else if ( info.gotPos )
4151 return self->Remove(info.pos);
4152 else
4153 return false;
4154 }
4155 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4156 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4157 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4158 wxPyEndBlockThreads(blocked);
4159 if ( info.window )
4160 return self->Detach(info.window);
4161 else if ( info.sizer )
4162 return self->Detach(info.sizer);
4163 else if ( info.gotPos )
4164 return self->Detach(info.pos);
4165 else
4166 return false;
4167 }
4168 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4169 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4170 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4171 wxPyEndBlockThreads(blocked);
4172 if ( info.window )
4173 return self->GetItem(info.window);
4174 else if ( info.sizer )
4175 return self->GetItem(info.sizer);
4176 else if ( info.gotPos )
4177 return self->GetItem(info.pos);
4178 else
4179 return NULL;
4180 }
4181 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4182 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4183 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4184 wxPyEndBlockThreads(blocked);
4185 if ( info.window )
4186 self->SetItemMinSize(info.window, size);
4187 else if ( info.sizer )
4188 self->SetItemMinSize(info.sizer, size);
4189 else if ( info.gotPos )
4190 self->SetItemMinSize(info.pos, size);
4191 }
4192 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4193 wxSizerItemList& list = self->GetChildren();
4194 return wxPy_ConvertList(&list);
4195 }
4196 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4197 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4198 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4199 wxPyEndBlockThreads(blocked);
4200 if ( info.window )
4201 return self->Show(info.window, show, recursive);
4202 else if ( info.sizer )
4203 return self->Show(info.sizer, show, recursive);
4204 else if ( info.gotPos )
4205 return self->Show(info.pos, show);
4206 else
4207 return false;
4208 }
4209 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4210 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4211 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4212 wxPyEndBlockThreads(blocked);
4213 if ( info.window )
4214 return self->IsShown(info.window);
4215 else if ( info.sizer )
4216 return self->IsShown(info.sizer);
4217 else if ( info.gotPos )
4218 return self->IsShown(info.pos);
4219 else
4220 return false;
4221 }
4222
4223 // See pyclasses.h
4224 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4225 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4226 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4227
4228
4229
4230
4231 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4232 {
4233 if (source == Py_None) {
4234 **obj = wxGBPosition(-1,-1);
4235 return true;
4236 }
4237 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4238 }
4239
4240 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4241 {
4242 if (source == Py_None) {
4243 **obj = wxGBSpan(-1,-1);
4244 return true;
4245 }
4246 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4247 }
4248
4249
4250 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4251 wxGBPosition temp, *obj = &temp;
4252 if ( other == Py_None ) return false;
4253 if ( ! wxGBPosition_helper(other, &obj) ) {
4254 PyErr_Clear();
4255 return false;
4256 }
4257 return self->operator==(*obj);
4258 }
4259 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4260 wxGBPosition temp, *obj = &temp;
4261 if ( other == Py_None ) return true;
4262 if ( ! wxGBPosition_helper(other, &obj)) {
4263 PyErr_Clear();
4264 return true;
4265 }
4266 return self->operator!=(*obj);
4267 }
4268 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4269 self->SetRow(row);
4270 self->SetCol(col);
4271 }
4272 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4273 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4274 PyObject* tup = PyTuple_New(2);
4275 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4276 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4277 wxPyEndBlockThreads(blocked);
4278 return tup;
4279 }
4280 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4281 wxGBSpan temp, *obj = &temp;
4282 if ( other == Py_None ) return false;
4283 if ( ! wxGBSpan_helper(other, &obj) ) {
4284 PyErr_Clear();
4285 return false;
4286 }
4287 return self->operator==(*obj);
4288 }
4289 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4290 wxGBSpan temp, *obj = &temp;
4291 if ( other == Py_None ) return true;
4292 if ( ! wxGBSpan_helper(other, &obj)) {
4293 PyErr_Clear();
4294 return true;
4295 }
4296 return self->operator!=(*obj);
4297 }
4298 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4299 self->SetRowspan(rowspan);
4300 self->SetColspan(colspan);
4301 }
4302 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4303 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4304 PyObject* tup = PyTuple_New(2);
4305 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4306 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4307 wxPyEndBlockThreads(blocked);
4308 return tup;
4309 }
4310 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4311 wxPyUserData* data = NULL;
4312 if ( userData ) {
4313 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4314 data = new wxPyUserData(userData);
4315 wxPyEndBlockThreads(blocked);
4316 }
4317 return new wxGBSizerItem(window, pos, span, flag, border, data);
4318 }
4319 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4320 wxPyUserData* data = NULL;
4321 if ( userData ) {
4322 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4323 data = new wxPyUserData(userData);
4324 wxPyEndBlockThreads(blocked);
4325 }
4326 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4327 }
4328 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4329 wxPyUserData* data = NULL;
4330 if ( userData ) {
4331 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4332 data = new wxPyUserData(userData);
4333 wxPyEndBlockThreads(blocked);
4334 }
4335 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4336 }
4337 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4338 int row, col;
4339 self->GetEndPos(row, col);
4340 return wxGBPosition(row, col);
4341 }
4342 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4343
4344 wxPyUserData* data = NULL;
4345 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4346 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4347 if ( userData && (info.window || info.sizer || info.gotSize) )
4348 data = new wxPyUserData(userData);
4349 if ( info.sizer )
4350 PyObject_SetAttrString(item,"thisown",Py_False);
4351 wxPyEndBlockThreads(blocked);
4352
4353 // Now call the real Add method if a valid item type was found
4354 if ( info.window )
4355 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4356 else if ( info.sizer )
4357 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4358 else if (info.gotSize)
4359 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4360 pos, span, flag, border, data);
4361 return NULL;
4362 }
4363
4364
4365 #ifdef __cplusplus
4366 extern "C" {
4367 #endif
4368 SWIGINTERN int EmptyString_set(PyObject *) {
4369 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4370 return 1;
4371 }
4372
4373
4374 SWIGINTERN PyObject *EmptyString_get(void) {
4375 PyObject *pyobj = 0;
4376
4377 {
4378 #if wxUSE_UNICODE
4379 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4380 #else
4381 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4382 #endif
4383 }
4384 return pyobj;
4385 }
4386
4387
4388 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4389 PyObject *resultobj = 0;
4390 wxObject *arg1 = (wxObject *) 0 ;
4391 wxString result;
4392 void *argp1 = 0 ;
4393 int res1 = 0 ;
4394 PyObject *swig_obj[1] ;
4395
4396 if (!args) SWIG_fail;
4397 swig_obj[0] = args;
4398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4399 if (!SWIG_IsOK(res1)) {
4400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4401 }
4402 arg1 = reinterpret_cast< wxObject * >(argp1);
4403 {
4404 PyThreadState* __tstate = wxPyBeginAllowThreads();
4405 result = wxObject_GetClassName(arg1);
4406 wxPyEndAllowThreads(__tstate);
4407 if (PyErr_Occurred()) SWIG_fail;
4408 }
4409 {
4410 #if wxUSE_UNICODE
4411 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4412 #else
4413 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4414 #endif
4415 }
4416 return resultobj;
4417 fail:
4418 return NULL;
4419 }
4420
4421
4422 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4423 PyObject *resultobj = 0;
4424 wxObject *arg1 = (wxObject *) 0 ;
4425 void *argp1 = 0 ;
4426 int res1 = 0 ;
4427 PyObject *swig_obj[1] ;
4428
4429 if (!args) SWIG_fail;
4430 swig_obj[0] = args;
4431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4432 if (!SWIG_IsOK(res1)) {
4433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4434 }
4435 arg1 = reinterpret_cast< wxObject * >(argp1);
4436 {
4437 PyThreadState* __tstate = wxPyBeginAllowThreads();
4438 wxObject_Destroy(arg1);
4439 wxPyEndAllowThreads(__tstate);
4440 if (PyErr_Occurred()) SWIG_fail;
4441 }
4442 resultobj = SWIG_Py_Void();
4443 return resultobj;
4444 fail:
4445 return NULL;
4446 }
4447
4448
4449 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4450 PyObject *obj;
4451 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4452 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4453 return SWIG_Py_Void();
4454 }
4455
4456 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4457 PyObject *resultobj = 0;
4458 wxSize *arg1 = (wxSize *) 0 ;
4459 int arg2 ;
4460 void *argp1 = 0 ;
4461 int res1 = 0 ;
4462 int val2 ;
4463 int ecode2 = 0 ;
4464 PyObject *swig_obj[2] ;
4465
4466 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4468 if (!SWIG_IsOK(res1)) {
4469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4470 }
4471 arg1 = reinterpret_cast< wxSize * >(argp1);
4472 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4473 if (!SWIG_IsOK(ecode2)) {
4474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4475 }
4476 arg2 = static_cast< int >(val2);
4477 if (arg1) (arg1)->x = arg2;
4478
4479 resultobj = SWIG_Py_Void();
4480 return resultobj;
4481 fail:
4482 return NULL;
4483 }
4484
4485
4486 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4487 PyObject *resultobj = 0;
4488 wxSize *arg1 = (wxSize *) 0 ;
4489 int result;
4490 void *argp1 = 0 ;
4491 int res1 = 0 ;
4492 PyObject *swig_obj[1] ;
4493
4494 if (!args) SWIG_fail;
4495 swig_obj[0] = args;
4496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4497 if (!SWIG_IsOK(res1)) {
4498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4499 }
4500 arg1 = reinterpret_cast< wxSize * >(argp1);
4501 result = (int) ((arg1)->x);
4502 resultobj = SWIG_From_int(static_cast< int >(result));
4503 return resultobj;
4504 fail:
4505 return NULL;
4506 }
4507
4508
4509 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4510 PyObject *resultobj = 0;
4511 wxSize *arg1 = (wxSize *) 0 ;
4512 int arg2 ;
4513 void *argp1 = 0 ;
4514 int res1 = 0 ;
4515 int val2 ;
4516 int ecode2 = 0 ;
4517 PyObject *swig_obj[2] ;
4518
4519 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4521 if (!SWIG_IsOK(res1)) {
4522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4523 }
4524 arg1 = reinterpret_cast< wxSize * >(argp1);
4525 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4526 if (!SWIG_IsOK(ecode2)) {
4527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4528 }
4529 arg2 = static_cast< int >(val2);
4530 if (arg1) (arg1)->y = arg2;
4531
4532 resultobj = SWIG_Py_Void();
4533 return resultobj;
4534 fail:
4535 return NULL;
4536 }
4537
4538
4539 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4540 PyObject *resultobj = 0;
4541 wxSize *arg1 = (wxSize *) 0 ;
4542 int result;
4543 void *argp1 = 0 ;
4544 int res1 = 0 ;
4545 PyObject *swig_obj[1] ;
4546
4547 if (!args) SWIG_fail;
4548 swig_obj[0] = args;
4549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4550 if (!SWIG_IsOK(res1)) {
4551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4552 }
4553 arg1 = reinterpret_cast< wxSize * >(argp1);
4554 result = (int) ((arg1)->y);
4555 resultobj = SWIG_From_int(static_cast< int >(result));
4556 return resultobj;
4557 fail:
4558 return NULL;
4559 }
4560
4561
4562 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4563 PyObject *resultobj = 0;
4564 int arg1 = (int) 0 ;
4565 int arg2 = (int) 0 ;
4566 wxSize *result = 0 ;
4567 int val1 ;
4568 int ecode1 = 0 ;
4569 int val2 ;
4570 int ecode2 = 0 ;
4571 PyObject * obj0 = 0 ;
4572 PyObject * obj1 = 0 ;
4573 char * kwnames[] = {
4574 (char *) "w",(char *) "h", NULL
4575 };
4576
4577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4578 if (obj0) {
4579 ecode1 = SWIG_AsVal_int(obj0, &val1);
4580 if (!SWIG_IsOK(ecode1)) {
4581 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4582 }
4583 arg1 = static_cast< int >(val1);
4584 }
4585 if (obj1) {
4586 ecode2 = SWIG_AsVal_int(obj1, &val2);
4587 if (!SWIG_IsOK(ecode2)) {
4588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4589 }
4590 arg2 = static_cast< int >(val2);
4591 }
4592 {
4593 PyThreadState* __tstate = wxPyBeginAllowThreads();
4594 result = (wxSize *)new wxSize(arg1,arg2);
4595 wxPyEndAllowThreads(__tstate);
4596 if (PyErr_Occurred()) SWIG_fail;
4597 }
4598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4599 return resultobj;
4600 fail:
4601 return NULL;
4602 }
4603
4604
4605 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4606 PyObject *resultobj = 0;
4607 wxSize *arg1 = (wxSize *) 0 ;
4608 void *argp1 = 0 ;
4609 int res1 = 0 ;
4610 PyObject *swig_obj[1] ;
4611
4612 if (!args) SWIG_fail;
4613 swig_obj[0] = args;
4614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4615 if (!SWIG_IsOK(res1)) {
4616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4617 }
4618 arg1 = reinterpret_cast< wxSize * >(argp1);
4619 {
4620 PyThreadState* __tstate = wxPyBeginAllowThreads();
4621 delete arg1;
4622
4623 wxPyEndAllowThreads(__tstate);
4624 if (PyErr_Occurred()) SWIG_fail;
4625 }
4626 resultobj = SWIG_Py_Void();
4627 return resultobj;
4628 fail:
4629 return NULL;
4630 }
4631
4632
4633 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4634 PyObject *resultobj = 0;
4635 wxSize *arg1 = (wxSize *) 0 ;
4636 PyObject *arg2 = (PyObject *) 0 ;
4637 bool result;
4638 void *argp1 = 0 ;
4639 int res1 = 0 ;
4640 PyObject * obj0 = 0 ;
4641 PyObject * obj1 = 0 ;
4642 char * kwnames[] = {
4643 (char *) "self",(char *) "other", NULL
4644 };
4645
4646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4648 if (!SWIG_IsOK(res1)) {
4649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4650 }
4651 arg1 = reinterpret_cast< wxSize * >(argp1);
4652 arg2 = obj1;
4653 {
4654 result = (bool)wxSize___eq__(arg1,arg2);
4655 if (PyErr_Occurred()) SWIG_fail;
4656 }
4657 {
4658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4659 }
4660 return resultobj;
4661 fail:
4662 return NULL;
4663 }
4664
4665
4666 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4667 PyObject *resultobj = 0;
4668 wxSize *arg1 = (wxSize *) 0 ;
4669 PyObject *arg2 = (PyObject *) 0 ;
4670 bool result;
4671 void *argp1 = 0 ;
4672 int res1 = 0 ;
4673 PyObject * obj0 = 0 ;
4674 PyObject * obj1 = 0 ;
4675 char * kwnames[] = {
4676 (char *) "self",(char *) "other", NULL
4677 };
4678
4679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4681 if (!SWIG_IsOK(res1)) {
4682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4683 }
4684 arg1 = reinterpret_cast< wxSize * >(argp1);
4685 arg2 = obj1;
4686 {
4687 result = (bool)wxSize___ne__(arg1,arg2);
4688 if (PyErr_Occurred()) SWIG_fail;
4689 }
4690 {
4691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4692 }
4693 return resultobj;
4694 fail:
4695 return NULL;
4696 }
4697
4698
4699 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4700 PyObject *resultobj = 0;
4701 wxSize *arg1 = (wxSize *) 0 ;
4702 wxSize *arg2 = 0 ;
4703 wxSize result;
4704 void *argp1 = 0 ;
4705 int res1 = 0 ;
4706 wxSize temp2 ;
4707 PyObject * obj0 = 0 ;
4708 PyObject * obj1 = 0 ;
4709 char * kwnames[] = {
4710 (char *) "self",(char *) "sz", NULL
4711 };
4712
4713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4715 if (!SWIG_IsOK(res1)) {
4716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4717 }
4718 arg1 = reinterpret_cast< wxSize * >(argp1);
4719 {
4720 arg2 = &temp2;
4721 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4722 }
4723 {
4724 PyThreadState* __tstate = wxPyBeginAllowThreads();
4725 result = (arg1)->operator +((wxSize const &)*arg2);
4726 wxPyEndAllowThreads(__tstate);
4727 if (PyErr_Occurred()) SWIG_fail;
4728 }
4729 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4730 return resultobj;
4731 fail:
4732 return NULL;
4733 }
4734
4735
4736 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4737 PyObject *resultobj = 0;
4738 wxSize *arg1 = (wxSize *) 0 ;
4739 wxSize *arg2 = 0 ;
4740 wxSize result;
4741 void *argp1 = 0 ;
4742 int res1 = 0 ;
4743 wxSize temp2 ;
4744 PyObject * obj0 = 0 ;
4745 PyObject * obj1 = 0 ;
4746 char * kwnames[] = {
4747 (char *) "self",(char *) "sz", NULL
4748 };
4749
4750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4752 if (!SWIG_IsOK(res1)) {
4753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4754 }
4755 arg1 = reinterpret_cast< wxSize * >(argp1);
4756 {
4757 arg2 = &temp2;
4758 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4759 }
4760 {
4761 PyThreadState* __tstate = wxPyBeginAllowThreads();
4762 result = (arg1)->operator -((wxSize const &)*arg2);
4763 wxPyEndAllowThreads(__tstate);
4764 if (PyErr_Occurred()) SWIG_fail;
4765 }
4766 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4767 return resultobj;
4768 fail:
4769 return NULL;
4770 }
4771
4772
4773 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4774 PyObject *resultobj = 0;
4775 wxSize *arg1 = (wxSize *) 0 ;
4776 wxSize *arg2 = 0 ;
4777 void *argp1 = 0 ;
4778 int res1 = 0 ;
4779 wxSize temp2 ;
4780 PyObject * obj0 = 0 ;
4781 PyObject * obj1 = 0 ;
4782 char * kwnames[] = {
4783 (char *) "self",(char *) "sz", NULL
4784 };
4785
4786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4788 if (!SWIG_IsOK(res1)) {
4789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4790 }
4791 arg1 = reinterpret_cast< wxSize * >(argp1);
4792 {
4793 arg2 = &temp2;
4794 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4795 }
4796 {
4797 PyThreadState* __tstate = wxPyBeginAllowThreads();
4798 (arg1)->IncTo((wxSize const &)*arg2);
4799 wxPyEndAllowThreads(__tstate);
4800 if (PyErr_Occurred()) SWIG_fail;
4801 }
4802 resultobj = SWIG_Py_Void();
4803 return resultobj;
4804 fail:
4805 return NULL;
4806 }
4807
4808
4809 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4810 PyObject *resultobj = 0;
4811 wxSize *arg1 = (wxSize *) 0 ;
4812 wxSize *arg2 = 0 ;
4813 void *argp1 = 0 ;
4814 int res1 = 0 ;
4815 wxSize temp2 ;
4816 PyObject * obj0 = 0 ;
4817 PyObject * obj1 = 0 ;
4818 char * kwnames[] = {
4819 (char *) "self",(char *) "sz", NULL
4820 };
4821
4822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4824 if (!SWIG_IsOK(res1)) {
4825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4826 }
4827 arg1 = reinterpret_cast< wxSize * >(argp1);
4828 {
4829 arg2 = &temp2;
4830 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4831 }
4832 {
4833 PyThreadState* __tstate = wxPyBeginAllowThreads();
4834 (arg1)->DecTo((wxSize const &)*arg2);
4835 wxPyEndAllowThreads(__tstate);
4836 if (PyErr_Occurred()) SWIG_fail;
4837 }
4838 resultobj = SWIG_Py_Void();
4839 return resultobj;
4840 fail:
4841 return NULL;
4842 }
4843
4844
4845 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4846 PyObject *resultobj = 0;
4847 wxSize *arg1 = (wxSize *) 0 ;
4848 int arg2 ;
4849 int arg3 ;
4850 void *argp1 = 0 ;
4851 int res1 = 0 ;
4852 int val2 ;
4853 int ecode2 = 0 ;
4854 int val3 ;
4855 int ecode3 = 0 ;
4856 PyObject * obj0 = 0 ;
4857 PyObject * obj1 = 0 ;
4858 PyObject * obj2 = 0 ;
4859 char * kwnames[] = {
4860 (char *) "self",(char *) "w",(char *) "h", NULL
4861 };
4862
4863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4865 if (!SWIG_IsOK(res1)) {
4866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4867 }
4868 arg1 = reinterpret_cast< wxSize * >(argp1);
4869 ecode2 = SWIG_AsVal_int(obj1, &val2);
4870 if (!SWIG_IsOK(ecode2)) {
4871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4872 }
4873 arg2 = static_cast< int >(val2);
4874 ecode3 = SWIG_AsVal_int(obj2, &val3);
4875 if (!SWIG_IsOK(ecode3)) {
4876 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4877 }
4878 arg3 = static_cast< int >(val3);
4879 {
4880 PyThreadState* __tstate = wxPyBeginAllowThreads();
4881 (arg1)->Set(arg2,arg3);
4882 wxPyEndAllowThreads(__tstate);
4883 if (PyErr_Occurred()) SWIG_fail;
4884 }
4885 resultobj = SWIG_Py_Void();
4886 return resultobj;
4887 fail:
4888 return NULL;
4889 }
4890
4891
4892 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4893 PyObject *resultobj = 0;
4894 wxSize *arg1 = (wxSize *) 0 ;
4895 int arg2 ;
4896 void *argp1 = 0 ;
4897 int res1 = 0 ;
4898 int val2 ;
4899 int ecode2 = 0 ;
4900 PyObject * obj0 = 0 ;
4901 PyObject * obj1 = 0 ;
4902 char * kwnames[] = {
4903 (char *) "self",(char *) "w", NULL
4904 };
4905
4906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4908 if (!SWIG_IsOK(res1)) {
4909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4910 }
4911 arg1 = reinterpret_cast< wxSize * >(argp1);
4912 ecode2 = SWIG_AsVal_int(obj1, &val2);
4913 if (!SWIG_IsOK(ecode2)) {
4914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4915 }
4916 arg2 = static_cast< int >(val2);
4917 {
4918 PyThreadState* __tstate = wxPyBeginAllowThreads();
4919 (arg1)->SetWidth(arg2);
4920 wxPyEndAllowThreads(__tstate);
4921 if (PyErr_Occurred()) SWIG_fail;
4922 }
4923 resultobj = SWIG_Py_Void();
4924 return resultobj;
4925 fail:
4926 return NULL;
4927 }
4928
4929
4930 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4931 PyObject *resultobj = 0;
4932 wxSize *arg1 = (wxSize *) 0 ;
4933 int arg2 ;
4934 void *argp1 = 0 ;
4935 int res1 = 0 ;
4936 int val2 ;
4937 int ecode2 = 0 ;
4938 PyObject * obj0 = 0 ;
4939 PyObject * obj1 = 0 ;
4940 char * kwnames[] = {
4941 (char *) "self",(char *) "h", NULL
4942 };
4943
4944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4946 if (!SWIG_IsOK(res1)) {
4947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4948 }
4949 arg1 = reinterpret_cast< wxSize * >(argp1);
4950 ecode2 = SWIG_AsVal_int(obj1, &val2);
4951 if (!SWIG_IsOK(ecode2)) {
4952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4953 }
4954 arg2 = static_cast< int >(val2);
4955 {
4956 PyThreadState* __tstate = wxPyBeginAllowThreads();
4957 (arg1)->SetHeight(arg2);
4958 wxPyEndAllowThreads(__tstate);
4959 if (PyErr_Occurred()) SWIG_fail;
4960 }
4961 resultobj = SWIG_Py_Void();
4962 return resultobj;
4963 fail:
4964 return NULL;
4965 }
4966
4967
4968 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4969 PyObject *resultobj = 0;
4970 wxSize *arg1 = (wxSize *) 0 ;
4971 int result;
4972 void *argp1 = 0 ;
4973 int res1 = 0 ;
4974 PyObject *swig_obj[1] ;
4975
4976 if (!args) SWIG_fail;
4977 swig_obj[0] = args;
4978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4979 if (!SWIG_IsOK(res1)) {
4980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4981 }
4982 arg1 = reinterpret_cast< wxSize * >(argp1);
4983 {
4984 PyThreadState* __tstate = wxPyBeginAllowThreads();
4985 result = (int)((wxSize const *)arg1)->GetWidth();
4986 wxPyEndAllowThreads(__tstate);
4987 if (PyErr_Occurred()) SWIG_fail;
4988 }
4989 resultobj = SWIG_From_int(static_cast< int >(result));
4990 return resultobj;
4991 fail:
4992 return NULL;
4993 }
4994
4995
4996 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4997 PyObject *resultobj = 0;
4998 wxSize *arg1 = (wxSize *) 0 ;
4999 int result;
5000 void *argp1 = 0 ;
5001 int res1 = 0 ;
5002 PyObject *swig_obj[1] ;
5003
5004 if (!args) SWIG_fail;
5005 swig_obj[0] = args;
5006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5007 if (!SWIG_IsOK(res1)) {
5008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5009 }
5010 arg1 = reinterpret_cast< wxSize * >(argp1);
5011 {
5012 PyThreadState* __tstate = wxPyBeginAllowThreads();
5013 result = (int)((wxSize const *)arg1)->GetHeight();
5014 wxPyEndAllowThreads(__tstate);
5015 if (PyErr_Occurred()) SWIG_fail;
5016 }
5017 resultobj = SWIG_From_int(static_cast< int >(result));
5018 return resultobj;
5019 fail:
5020 return NULL;
5021 }
5022
5023
5024 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5025 PyObject *resultobj = 0;
5026 wxSize *arg1 = (wxSize *) 0 ;
5027 bool result;
5028 void *argp1 = 0 ;
5029 int res1 = 0 ;
5030 PyObject *swig_obj[1] ;
5031
5032 if (!args) SWIG_fail;
5033 swig_obj[0] = args;
5034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5035 if (!SWIG_IsOK(res1)) {
5036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5037 }
5038 arg1 = reinterpret_cast< wxSize * >(argp1);
5039 {
5040 PyThreadState* __tstate = wxPyBeginAllowThreads();
5041 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5042 wxPyEndAllowThreads(__tstate);
5043 if (PyErr_Occurred()) SWIG_fail;
5044 }
5045 {
5046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5047 }
5048 return resultobj;
5049 fail:
5050 return NULL;
5051 }
5052
5053
5054 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5055 PyObject *resultobj = 0;
5056 wxSize *arg1 = (wxSize *) 0 ;
5057 wxSize *arg2 = 0 ;
5058 void *argp1 = 0 ;
5059 int res1 = 0 ;
5060 wxSize temp2 ;
5061 PyObject * obj0 = 0 ;
5062 PyObject * obj1 = 0 ;
5063 char * kwnames[] = {
5064 (char *) "self",(char *) "size", NULL
5065 };
5066
5067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5069 if (!SWIG_IsOK(res1)) {
5070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5071 }
5072 arg1 = reinterpret_cast< wxSize * >(argp1);
5073 {
5074 arg2 = &temp2;
5075 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5076 }
5077 {
5078 PyThreadState* __tstate = wxPyBeginAllowThreads();
5079 (arg1)->SetDefaults((wxSize const &)*arg2);
5080 wxPyEndAllowThreads(__tstate);
5081 if (PyErr_Occurred()) SWIG_fail;
5082 }
5083 resultobj = SWIG_Py_Void();
5084 return resultobj;
5085 fail:
5086 return NULL;
5087 }
5088
5089
5090 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5091 PyObject *resultobj = 0;
5092 wxSize *arg1 = (wxSize *) 0 ;
5093 PyObject *result = 0 ;
5094 void *argp1 = 0 ;
5095 int res1 = 0 ;
5096 PyObject *swig_obj[1] ;
5097
5098 if (!args) SWIG_fail;
5099 swig_obj[0] = args;
5100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5101 if (!SWIG_IsOK(res1)) {
5102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5103 }
5104 arg1 = reinterpret_cast< wxSize * >(argp1);
5105 {
5106 PyThreadState* __tstate = wxPyBeginAllowThreads();
5107 result = (PyObject *)wxSize_Get(arg1);
5108 wxPyEndAllowThreads(__tstate);
5109 if (PyErr_Occurred()) SWIG_fail;
5110 }
5111 resultobj = result;
5112 return resultobj;
5113 fail:
5114 return NULL;
5115 }
5116
5117
5118 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5119 PyObject *obj;
5120 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5121 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5122 return SWIG_Py_Void();
5123 }
5124
5125 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5126 return SWIG_Python_InitShadowInstance(args);
5127 }
5128
5129 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5130 PyObject *resultobj = 0;
5131 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5132 double arg2 ;
5133 void *argp1 = 0 ;
5134 int res1 = 0 ;
5135 double val2 ;
5136 int ecode2 = 0 ;
5137 PyObject *swig_obj[2] ;
5138
5139 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5141 if (!SWIG_IsOK(res1)) {
5142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5143 }
5144 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5145 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5146 if (!SWIG_IsOK(ecode2)) {
5147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5148 }
5149 arg2 = static_cast< double >(val2);
5150 if (arg1) (arg1)->x = arg2;
5151
5152 resultobj = SWIG_Py_Void();
5153 return resultobj;
5154 fail:
5155 return NULL;
5156 }
5157
5158
5159 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5160 PyObject *resultobj = 0;
5161 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5162 double result;
5163 void *argp1 = 0 ;
5164 int res1 = 0 ;
5165 PyObject *swig_obj[1] ;
5166
5167 if (!args) SWIG_fail;
5168 swig_obj[0] = args;
5169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5170 if (!SWIG_IsOK(res1)) {
5171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5172 }
5173 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5174 result = (double) ((arg1)->x);
5175 resultobj = SWIG_From_double(static_cast< double >(result));
5176 return resultobj;
5177 fail:
5178 return NULL;
5179 }
5180
5181
5182 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5183 PyObject *resultobj = 0;
5184 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5185 double arg2 ;
5186 void *argp1 = 0 ;
5187 int res1 = 0 ;
5188 double val2 ;
5189 int ecode2 = 0 ;
5190 PyObject *swig_obj[2] ;
5191
5192 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5194 if (!SWIG_IsOK(res1)) {
5195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5196 }
5197 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5198 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5199 if (!SWIG_IsOK(ecode2)) {
5200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5201 }
5202 arg2 = static_cast< double >(val2);
5203 if (arg1) (arg1)->y = arg2;
5204
5205 resultobj = SWIG_Py_Void();
5206 return resultobj;
5207 fail:
5208 return NULL;
5209 }
5210
5211
5212 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5213 PyObject *resultobj = 0;
5214 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5215 double result;
5216 void *argp1 = 0 ;
5217 int res1 = 0 ;
5218 PyObject *swig_obj[1] ;
5219
5220 if (!args) SWIG_fail;
5221 swig_obj[0] = args;
5222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5223 if (!SWIG_IsOK(res1)) {
5224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5225 }
5226 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5227 result = (double) ((arg1)->y);
5228 resultobj = SWIG_From_double(static_cast< double >(result));
5229 return resultobj;
5230 fail:
5231 return NULL;
5232 }
5233
5234
5235 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5236 PyObject *resultobj = 0;
5237 double arg1 = (double) 0.0 ;
5238 double arg2 = (double) 0.0 ;
5239 wxRealPoint *result = 0 ;
5240 double val1 ;
5241 int ecode1 = 0 ;
5242 double val2 ;
5243 int ecode2 = 0 ;
5244 PyObject * obj0 = 0 ;
5245 PyObject * obj1 = 0 ;
5246 char * kwnames[] = {
5247 (char *) "x",(char *) "y", NULL
5248 };
5249
5250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5251 if (obj0) {
5252 ecode1 = SWIG_AsVal_double(obj0, &val1);
5253 if (!SWIG_IsOK(ecode1)) {
5254 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5255 }
5256 arg1 = static_cast< double >(val1);
5257 }
5258 if (obj1) {
5259 ecode2 = SWIG_AsVal_double(obj1, &val2);
5260 if (!SWIG_IsOK(ecode2)) {
5261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5262 }
5263 arg2 = static_cast< double >(val2);
5264 }
5265 {
5266 PyThreadState* __tstate = wxPyBeginAllowThreads();
5267 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5268 wxPyEndAllowThreads(__tstate);
5269 if (PyErr_Occurred()) SWIG_fail;
5270 }
5271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5272 return resultobj;
5273 fail:
5274 return NULL;
5275 }
5276
5277
5278 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5279 PyObject *resultobj = 0;
5280 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5281 void *argp1 = 0 ;
5282 int res1 = 0 ;
5283 PyObject *swig_obj[1] ;
5284
5285 if (!args) SWIG_fail;
5286 swig_obj[0] = args;
5287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5288 if (!SWIG_IsOK(res1)) {
5289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5290 }
5291 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5292 {
5293 PyThreadState* __tstate = wxPyBeginAllowThreads();
5294 delete arg1;
5295
5296 wxPyEndAllowThreads(__tstate);
5297 if (PyErr_Occurred()) SWIG_fail;
5298 }
5299 resultobj = SWIG_Py_Void();
5300 return resultobj;
5301 fail:
5302 return NULL;
5303 }
5304
5305
5306 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5307 PyObject *resultobj = 0;
5308 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5309 PyObject *arg2 = (PyObject *) 0 ;
5310 bool result;
5311 void *argp1 = 0 ;
5312 int res1 = 0 ;
5313 PyObject * obj0 = 0 ;
5314 PyObject * obj1 = 0 ;
5315 char * kwnames[] = {
5316 (char *) "self",(char *) "other", NULL
5317 };
5318
5319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5321 if (!SWIG_IsOK(res1)) {
5322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5323 }
5324 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5325 arg2 = obj1;
5326 {
5327 result = (bool)wxRealPoint___eq__(arg1,arg2);
5328 if (PyErr_Occurred()) SWIG_fail;
5329 }
5330 {
5331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5332 }
5333 return resultobj;
5334 fail:
5335 return NULL;
5336 }
5337
5338
5339 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5340 PyObject *resultobj = 0;
5341 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5342 PyObject *arg2 = (PyObject *) 0 ;
5343 bool result;
5344 void *argp1 = 0 ;
5345 int res1 = 0 ;
5346 PyObject * obj0 = 0 ;
5347 PyObject * obj1 = 0 ;
5348 char * kwnames[] = {
5349 (char *) "self",(char *) "other", NULL
5350 };
5351
5352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5354 if (!SWIG_IsOK(res1)) {
5355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5356 }
5357 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5358 arg2 = obj1;
5359 {
5360 result = (bool)wxRealPoint___ne__(arg1,arg2);
5361 if (PyErr_Occurred()) SWIG_fail;
5362 }
5363 {
5364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5365 }
5366 return resultobj;
5367 fail:
5368 return NULL;
5369 }
5370
5371
5372 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5373 PyObject *resultobj = 0;
5374 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5375 wxRealPoint *arg2 = 0 ;
5376 wxRealPoint result;
5377 void *argp1 = 0 ;
5378 int res1 = 0 ;
5379 wxRealPoint temp2 ;
5380 PyObject * obj0 = 0 ;
5381 PyObject * obj1 = 0 ;
5382 char * kwnames[] = {
5383 (char *) "self",(char *) "pt", NULL
5384 };
5385
5386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5388 if (!SWIG_IsOK(res1)) {
5389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5390 }
5391 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5392 {
5393 arg2 = &temp2;
5394 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5395 }
5396 {
5397 PyThreadState* __tstate = wxPyBeginAllowThreads();
5398 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5399 wxPyEndAllowThreads(__tstate);
5400 if (PyErr_Occurred()) SWIG_fail;
5401 }
5402 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5403 return resultobj;
5404 fail:
5405 return NULL;
5406 }
5407
5408
5409 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5410 PyObject *resultobj = 0;
5411 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5412 wxRealPoint *arg2 = 0 ;
5413 wxRealPoint result;
5414 void *argp1 = 0 ;
5415 int res1 = 0 ;
5416 wxRealPoint temp2 ;
5417 PyObject * obj0 = 0 ;
5418 PyObject * obj1 = 0 ;
5419 char * kwnames[] = {
5420 (char *) "self",(char *) "pt", NULL
5421 };
5422
5423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5425 if (!SWIG_IsOK(res1)) {
5426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5427 }
5428 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5429 {
5430 arg2 = &temp2;
5431 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5432 }
5433 {
5434 PyThreadState* __tstate = wxPyBeginAllowThreads();
5435 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5440 return resultobj;
5441 fail:
5442 return NULL;
5443 }
5444
5445
5446 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5447 PyObject *resultobj = 0;
5448 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5449 double arg2 ;
5450 double arg3 ;
5451 void *argp1 = 0 ;
5452 int res1 = 0 ;
5453 double val2 ;
5454 int ecode2 = 0 ;
5455 double val3 ;
5456 int ecode3 = 0 ;
5457 PyObject * obj0 = 0 ;
5458 PyObject * obj1 = 0 ;
5459 PyObject * obj2 = 0 ;
5460 char * kwnames[] = {
5461 (char *) "self",(char *) "x",(char *) "y", NULL
5462 };
5463
5464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5466 if (!SWIG_IsOK(res1)) {
5467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5468 }
5469 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5470 ecode2 = SWIG_AsVal_double(obj1, &val2);
5471 if (!SWIG_IsOK(ecode2)) {
5472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5473 }
5474 arg2 = static_cast< double >(val2);
5475 ecode3 = SWIG_AsVal_double(obj2, &val3);
5476 if (!SWIG_IsOK(ecode3)) {
5477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5478 }
5479 arg3 = static_cast< double >(val3);
5480 {
5481 PyThreadState* __tstate = wxPyBeginAllowThreads();
5482 wxRealPoint_Set(arg1,arg2,arg3);
5483 wxPyEndAllowThreads(__tstate);
5484 if (PyErr_Occurred()) SWIG_fail;
5485 }
5486 resultobj = SWIG_Py_Void();
5487 return resultobj;
5488 fail:
5489 return NULL;
5490 }
5491
5492
5493 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5494 PyObject *resultobj = 0;
5495 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5496 PyObject *result = 0 ;
5497 void *argp1 = 0 ;
5498 int res1 = 0 ;
5499 PyObject *swig_obj[1] ;
5500
5501 if (!args) SWIG_fail;
5502 swig_obj[0] = args;
5503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5504 if (!SWIG_IsOK(res1)) {
5505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5506 }
5507 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5508 {
5509 PyThreadState* __tstate = wxPyBeginAllowThreads();
5510 result = (PyObject *)wxRealPoint_Get(arg1);
5511 wxPyEndAllowThreads(__tstate);
5512 if (PyErr_Occurred()) SWIG_fail;
5513 }
5514 resultobj = result;
5515 return resultobj;
5516 fail:
5517 return NULL;
5518 }
5519
5520
5521 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5522 PyObject *obj;
5523 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5524 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5525 return SWIG_Py_Void();
5526 }
5527
5528 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5529 return SWIG_Python_InitShadowInstance(args);
5530 }
5531
5532 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5533 PyObject *resultobj = 0;
5534 wxPoint *arg1 = (wxPoint *) 0 ;
5535 int arg2 ;
5536 void *argp1 = 0 ;
5537 int res1 = 0 ;
5538 int val2 ;
5539 int ecode2 = 0 ;
5540 PyObject *swig_obj[2] ;
5541
5542 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5544 if (!SWIG_IsOK(res1)) {
5545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5546 }
5547 arg1 = reinterpret_cast< wxPoint * >(argp1);
5548 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5549 if (!SWIG_IsOK(ecode2)) {
5550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5551 }
5552 arg2 = static_cast< int >(val2);
5553 if (arg1) (arg1)->x = arg2;
5554
5555 resultobj = SWIG_Py_Void();
5556 return resultobj;
5557 fail:
5558 return NULL;
5559 }
5560
5561
5562 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5563 PyObject *resultobj = 0;
5564 wxPoint *arg1 = (wxPoint *) 0 ;
5565 int result;
5566 void *argp1 = 0 ;
5567 int res1 = 0 ;
5568 PyObject *swig_obj[1] ;
5569
5570 if (!args) SWIG_fail;
5571 swig_obj[0] = args;
5572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5573 if (!SWIG_IsOK(res1)) {
5574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5575 }
5576 arg1 = reinterpret_cast< wxPoint * >(argp1);
5577 result = (int) ((arg1)->x);
5578 resultobj = SWIG_From_int(static_cast< int >(result));
5579 return resultobj;
5580 fail:
5581 return NULL;
5582 }
5583
5584
5585 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5586 PyObject *resultobj = 0;
5587 wxPoint *arg1 = (wxPoint *) 0 ;
5588 int arg2 ;
5589 void *argp1 = 0 ;
5590 int res1 = 0 ;
5591 int val2 ;
5592 int ecode2 = 0 ;
5593 PyObject *swig_obj[2] ;
5594
5595 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5597 if (!SWIG_IsOK(res1)) {
5598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5599 }
5600 arg1 = reinterpret_cast< wxPoint * >(argp1);
5601 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5602 if (!SWIG_IsOK(ecode2)) {
5603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5604 }
5605 arg2 = static_cast< int >(val2);
5606 if (arg1) (arg1)->y = arg2;
5607
5608 resultobj = SWIG_Py_Void();
5609 return resultobj;
5610 fail:
5611 return NULL;
5612 }
5613
5614
5615 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5616 PyObject *resultobj = 0;
5617 wxPoint *arg1 = (wxPoint *) 0 ;
5618 int result;
5619 void *argp1 = 0 ;
5620 int res1 = 0 ;
5621 PyObject *swig_obj[1] ;
5622
5623 if (!args) SWIG_fail;
5624 swig_obj[0] = args;
5625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5626 if (!SWIG_IsOK(res1)) {
5627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5628 }
5629 arg1 = reinterpret_cast< wxPoint * >(argp1);
5630 result = (int) ((arg1)->y);
5631 resultobj = SWIG_From_int(static_cast< int >(result));
5632 return resultobj;
5633 fail:
5634 return NULL;
5635 }
5636
5637
5638 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5639 PyObject *resultobj = 0;
5640 int arg1 = (int) 0 ;
5641 int arg2 = (int) 0 ;
5642 wxPoint *result = 0 ;
5643 int val1 ;
5644 int ecode1 = 0 ;
5645 int val2 ;
5646 int ecode2 = 0 ;
5647 PyObject * obj0 = 0 ;
5648 PyObject * obj1 = 0 ;
5649 char * kwnames[] = {
5650 (char *) "x",(char *) "y", NULL
5651 };
5652
5653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5654 if (obj0) {
5655 ecode1 = SWIG_AsVal_int(obj0, &val1);
5656 if (!SWIG_IsOK(ecode1)) {
5657 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5658 }
5659 arg1 = static_cast< int >(val1);
5660 }
5661 if (obj1) {
5662 ecode2 = SWIG_AsVal_int(obj1, &val2);
5663 if (!SWIG_IsOK(ecode2)) {
5664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5665 }
5666 arg2 = static_cast< int >(val2);
5667 }
5668 {
5669 PyThreadState* __tstate = wxPyBeginAllowThreads();
5670 result = (wxPoint *)new wxPoint(arg1,arg2);
5671 wxPyEndAllowThreads(__tstate);
5672 if (PyErr_Occurred()) SWIG_fail;
5673 }
5674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5675 return resultobj;
5676 fail:
5677 return NULL;
5678 }
5679
5680
5681 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5682 PyObject *resultobj = 0;
5683 wxPoint *arg1 = (wxPoint *) 0 ;
5684 void *argp1 = 0 ;
5685 int res1 = 0 ;
5686 PyObject *swig_obj[1] ;
5687
5688 if (!args) SWIG_fail;
5689 swig_obj[0] = args;
5690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5691 if (!SWIG_IsOK(res1)) {
5692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5693 }
5694 arg1 = reinterpret_cast< wxPoint * >(argp1);
5695 {
5696 PyThreadState* __tstate = wxPyBeginAllowThreads();
5697 delete arg1;
5698
5699 wxPyEndAllowThreads(__tstate);
5700 if (PyErr_Occurred()) SWIG_fail;
5701 }
5702 resultobj = SWIG_Py_Void();
5703 return resultobj;
5704 fail:
5705 return NULL;
5706 }
5707
5708
5709 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5710 PyObject *resultobj = 0;
5711 wxPoint *arg1 = (wxPoint *) 0 ;
5712 PyObject *arg2 = (PyObject *) 0 ;
5713 bool result;
5714 void *argp1 = 0 ;
5715 int res1 = 0 ;
5716 PyObject * obj0 = 0 ;
5717 PyObject * obj1 = 0 ;
5718 char * kwnames[] = {
5719 (char *) "self",(char *) "other", NULL
5720 };
5721
5722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5724 if (!SWIG_IsOK(res1)) {
5725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5726 }
5727 arg1 = reinterpret_cast< wxPoint * >(argp1);
5728 arg2 = obj1;
5729 {
5730 result = (bool)wxPoint___eq__(arg1,arg2);
5731 if (PyErr_Occurred()) SWIG_fail;
5732 }
5733 {
5734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5735 }
5736 return resultobj;
5737 fail:
5738 return NULL;
5739 }
5740
5741
5742 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5743 PyObject *resultobj = 0;
5744 wxPoint *arg1 = (wxPoint *) 0 ;
5745 PyObject *arg2 = (PyObject *) 0 ;
5746 bool result;
5747 void *argp1 = 0 ;
5748 int res1 = 0 ;
5749 PyObject * obj0 = 0 ;
5750 PyObject * obj1 = 0 ;
5751 char * kwnames[] = {
5752 (char *) "self",(char *) "other", NULL
5753 };
5754
5755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5757 if (!SWIG_IsOK(res1)) {
5758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5759 }
5760 arg1 = reinterpret_cast< wxPoint * >(argp1);
5761 arg2 = obj1;
5762 {
5763 result = (bool)wxPoint___ne__(arg1,arg2);
5764 if (PyErr_Occurred()) SWIG_fail;
5765 }
5766 {
5767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5768 }
5769 return resultobj;
5770 fail:
5771 return NULL;
5772 }
5773
5774
5775 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5776 PyObject *resultobj = 0;
5777 wxPoint *arg1 = (wxPoint *) 0 ;
5778 wxPoint *arg2 = 0 ;
5779 wxPoint result;
5780 void *argp1 = 0 ;
5781 int res1 = 0 ;
5782 wxPoint temp2 ;
5783 PyObject * obj0 = 0 ;
5784 PyObject * obj1 = 0 ;
5785 char * kwnames[] = {
5786 (char *) "self",(char *) "pt", NULL
5787 };
5788
5789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5791 if (!SWIG_IsOK(res1)) {
5792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5793 }
5794 arg1 = reinterpret_cast< wxPoint * >(argp1);
5795 {
5796 arg2 = &temp2;
5797 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5798 }
5799 {
5800 PyThreadState* __tstate = wxPyBeginAllowThreads();
5801 result = (arg1)->operator +((wxPoint const &)*arg2);
5802 wxPyEndAllowThreads(__tstate);
5803 if (PyErr_Occurred()) SWIG_fail;
5804 }
5805 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5806 return resultobj;
5807 fail:
5808 return NULL;
5809 }
5810
5811
5812 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5813 PyObject *resultobj = 0;
5814 wxPoint *arg1 = (wxPoint *) 0 ;
5815 wxPoint *arg2 = 0 ;
5816 wxPoint result;
5817 void *argp1 = 0 ;
5818 int res1 = 0 ;
5819 wxPoint temp2 ;
5820 PyObject * obj0 = 0 ;
5821 PyObject * obj1 = 0 ;
5822 char * kwnames[] = {
5823 (char *) "self",(char *) "pt", NULL
5824 };
5825
5826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5828 if (!SWIG_IsOK(res1)) {
5829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5830 }
5831 arg1 = reinterpret_cast< wxPoint * >(argp1);
5832 {
5833 arg2 = &temp2;
5834 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5835 }
5836 {
5837 PyThreadState* __tstate = wxPyBeginAllowThreads();
5838 result = (arg1)->operator -((wxPoint const &)*arg2);
5839 wxPyEndAllowThreads(__tstate);
5840 if (PyErr_Occurred()) SWIG_fail;
5841 }
5842 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5843 return resultobj;
5844 fail:
5845 return NULL;
5846 }
5847
5848
5849 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5850 PyObject *resultobj = 0;
5851 wxPoint *arg1 = (wxPoint *) 0 ;
5852 wxPoint *arg2 = 0 ;
5853 wxPoint *result = 0 ;
5854 void *argp1 = 0 ;
5855 int res1 = 0 ;
5856 wxPoint temp2 ;
5857 PyObject * obj0 = 0 ;
5858 PyObject * obj1 = 0 ;
5859 char * kwnames[] = {
5860 (char *) "self",(char *) "pt", NULL
5861 };
5862
5863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5865 if (!SWIG_IsOK(res1)) {
5866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5867 }
5868 arg1 = reinterpret_cast< wxPoint * >(argp1);
5869 {
5870 arg2 = &temp2;
5871 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5872 }
5873 {
5874 PyThreadState* __tstate = wxPyBeginAllowThreads();
5875 {
5876 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5877 result = (wxPoint *) &_result_ref;
5878 }
5879 wxPyEndAllowThreads(__tstate);
5880 if (PyErr_Occurred()) SWIG_fail;
5881 }
5882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5883 return resultobj;
5884 fail:
5885 return NULL;
5886 }
5887
5888
5889 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5890 PyObject *resultobj = 0;
5891 wxPoint *arg1 = (wxPoint *) 0 ;
5892 wxPoint *arg2 = 0 ;
5893 wxPoint *result = 0 ;
5894 void *argp1 = 0 ;
5895 int res1 = 0 ;
5896 wxPoint temp2 ;
5897 PyObject * obj0 = 0 ;
5898 PyObject * obj1 = 0 ;
5899 char * kwnames[] = {
5900 (char *) "self",(char *) "pt", NULL
5901 };
5902
5903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5905 if (!SWIG_IsOK(res1)) {
5906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5907 }
5908 arg1 = reinterpret_cast< wxPoint * >(argp1);
5909 {
5910 arg2 = &temp2;
5911 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5912 }
5913 {
5914 PyThreadState* __tstate = wxPyBeginAllowThreads();
5915 {
5916 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5917 result = (wxPoint *) &_result_ref;
5918 }
5919 wxPyEndAllowThreads(__tstate);
5920 if (PyErr_Occurred()) SWIG_fail;
5921 }
5922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5923 return resultobj;
5924 fail:
5925 return NULL;
5926 }
5927
5928
5929 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5930 PyObject *resultobj = 0;
5931 wxPoint *arg1 = (wxPoint *) 0 ;
5932 long arg2 ;
5933 long arg3 ;
5934 void *argp1 = 0 ;
5935 int res1 = 0 ;
5936 long val2 ;
5937 int ecode2 = 0 ;
5938 long val3 ;
5939 int ecode3 = 0 ;
5940 PyObject * obj0 = 0 ;
5941 PyObject * obj1 = 0 ;
5942 PyObject * obj2 = 0 ;
5943 char * kwnames[] = {
5944 (char *) "self",(char *) "x",(char *) "y", NULL
5945 };
5946
5947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5949 if (!SWIG_IsOK(res1)) {
5950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5951 }
5952 arg1 = reinterpret_cast< wxPoint * >(argp1);
5953 ecode2 = SWIG_AsVal_long(obj1, &val2);
5954 if (!SWIG_IsOK(ecode2)) {
5955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5956 }
5957 arg2 = static_cast< long >(val2);
5958 ecode3 = SWIG_AsVal_long(obj2, &val3);
5959 if (!SWIG_IsOK(ecode3)) {
5960 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5961 }
5962 arg3 = static_cast< long >(val3);
5963 {
5964 PyThreadState* __tstate = wxPyBeginAllowThreads();
5965 wxPoint_Set(arg1,arg2,arg3);
5966 wxPyEndAllowThreads(__tstate);
5967 if (PyErr_Occurred()) SWIG_fail;
5968 }
5969 resultobj = SWIG_Py_Void();
5970 return resultobj;
5971 fail:
5972 return NULL;
5973 }
5974
5975
5976 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5977 PyObject *resultobj = 0;
5978 wxPoint *arg1 = (wxPoint *) 0 ;
5979 PyObject *result = 0 ;
5980 void *argp1 = 0 ;
5981 int res1 = 0 ;
5982 PyObject *swig_obj[1] ;
5983
5984 if (!args) SWIG_fail;
5985 swig_obj[0] = args;
5986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5987 if (!SWIG_IsOK(res1)) {
5988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5989 }
5990 arg1 = reinterpret_cast< wxPoint * >(argp1);
5991 {
5992 PyThreadState* __tstate = wxPyBeginAllowThreads();
5993 result = (PyObject *)wxPoint_Get(arg1);
5994 wxPyEndAllowThreads(__tstate);
5995 if (PyErr_Occurred()) SWIG_fail;
5996 }
5997 resultobj = result;
5998 return resultobj;
5999 fail:
6000 return NULL;
6001 }
6002
6003
6004 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6005 PyObject *obj;
6006 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6007 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6008 return SWIG_Py_Void();
6009 }
6010
6011 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6012 return SWIG_Python_InitShadowInstance(args);
6013 }
6014
6015 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6016 PyObject *resultobj = 0;
6017 int arg1 = (int) 0 ;
6018 int arg2 = (int) 0 ;
6019 int arg3 = (int) 0 ;
6020 int arg4 = (int) 0 ;
6021 wxRect *result = 0 ;
6022 int val1 ;
6023 int ecode1 = 0 ;
6024 int val2 ;
6025 int ecode2 = 0 ;
6026 int val3 ;
6027 int ecode3 = 0 ;
6028 int val4 ;
6029 int ecode4 = 0 ;
6030 PyObject * obj0 = 0 ;
6031 PyObject * obj1 = 0 ;
6032 PyObject * obj2 = 0 ;
6033 PyObject * obj3 = 0 ;
6034 char * kwnames[] = {
6035 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6036 };
6037
6038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6039 if (obj0) {
6040 ecode1 = SWIG_AsVal_int(obj0, &val1);
6041 if (!SWIG_IsOK(ecode1)) {
6042 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6043 }
6044 arg1 = static_cast< int >(val1);
6045 }
6046 if (obj1) {
6047 ecode2 = SWIG_AsVal_int(obj1, &val2);
6048 if (!SWIG_IsOK(ecode2)) {
6049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6050 }
6051 arg2 = static_cast< int >(val2);
6052 }
6053 if (obj2) {
6054 ecode3 = SWIG_AsVal_int(obj2, &val3);
6055 if (!SWIG_IsOK(ecode3)) {
6056 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6057 }
6058 arg3 = static_cast< int >(val3);
6059 }
6060 if (obj3) {
6061 ecode4 = SWIG_AsVal_int(obj3, &val4);
6062 if (!SWIG_IsOK(ecode4)) {
6063 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6064 }
6065 arg4 = static_cast< int >(val4);
6066 }
6067 {
6068 PyThreadState* __tstate = wxPyBeginAllowThreads();
6069 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6070 wxPyEndAllowThreads(__tstate);
6071 if (PyErr_Occurred()) SWIG_fail;
6072 }
6073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6074 return resultobj;
6075 fail:
6076 return NULL;
6077 }
6078
6079
6080 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6081 PyObject *resultobj = 0;
6082 wxPoint *arg1 = 0 ;
6083 wxPoint *arg2 = 0 ;
6084 wxRect *result = 0 ;
6085 wxPoint temp1 ;
6086 wxPoint temp2 ;
6087 PyObject * obj0 = 0 ;
6088 PyObject * obj1 = 0 ;
6089 char * kwnames[] = {
6090 (char *) "topLeft",(char *) "bottomRight", NULL
6091 };
6092
6093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6094 {
6095 arg1 = &temp1;
6096 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6097 }
6098 {
6099 arg2 = &temp2;
6100 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6101 }
6102 {
6103 PyThreadState* __tstate = wxPyBeginAllowThreads();
6104 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6105 wxPyEndAllowThreads(__tstate);
6106 if (PyErr_Occurred()) SWIG_fail;
6107 }
6108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6109 return resultobj;
6110 fail:
6111 return NULL;
6112 }
6113
6114
6115 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6116 PyObject *resultobj = 0;
6117 wxPoint *arg1 = 0 ;
6118 wxSize *arg2 = 0 ;
6119 wxRect *result = 0 ;
6120 wxPoint temp1 ;
6121 wxSize temp2 ;
6122 PyObject * obj0 = 0 ;
6123 PyObject * obj1 = 0 ;
6124 char * kwnames[] = {
6125 (char *) "pos",(char *) "size", NULL
6126 };
6127
6128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6129 {
6130 arg1 = &temp1;
6131 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6132 }
6133 {
6134 arg2 = &temp2;
6135 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6136 }
6137 {
6138 PyThreadState* __tstate = wxPyBeginAllowThreads();
6139 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6140 wxPyEndAllowThreads(__tstate);
6141 if (PyErr_Occurred()) SWIG_fail;
6142 }
6143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6144 return resultobj;
6145 fail:
6146 return NULL;
6147 }
6148
6149
6150 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6151 PyObject *resultobj = 0;
6152 wxSize *arg1 = 0 ;
6153 wxRect *result = 0 ;
6154 wxSize temp1 ;
6155 PyObject * obj0 = 0 ;
6156 char * kwnames[] = {
6157 (char *) "size", NULL
6158 };
6159
6160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6161 {
6162 arg1 = &temp1;
6163 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6164 }
6165 {
6166 PyThreadState* __tstate = wxPyBeginAllowThreads();
6167 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6168 wxPyEndAllowThreads(__tstate);
6169 if (PyErr_Occurred()) SWIG_fail;
6170 }
6171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6172 return resultobj;
6173 fail:
6174 return NULL;
6175 }
6176
6177
6178 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6179 PyObject *resultobj = 0;
6180 wxRect *arg1 = (wxRect *) 0 ;
6181 void *argp1 = 0 ;
6182 int res1 = 0 ;
6183 PyObject *swig_obj[1] ;
6184
6185 if (!args) SWIG_fail;
6186 swig_obj[0] = args;
6187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6188 if (!SWIG_IsOK(res1)) {
6189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6190 }
6191 arg1 = reinterpret_cast< wxRect * >(argp1);
6192 {
6193 PyThreadState* __tstate = wxPyBeginAllowThreads();
6194 delete arg1;
6195
6196 wxPyEndAllowThreads(__tstate);
6197 if (PyErr_Occurred()) SWIG_fail;
6198 }
6199 resultobj = SWIG_Py_Void();
6200 return resultobj;
6201 fail:
6202 return NULL;
6203 }
6204
6205
6206 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6207 PyObject *resultobj = 0;
6208 wxRect *arg1 = (wxRect *) 0 ;
6209 int result;
6210 void *argp1 = 0 ;
6211 int res1 = 0 ;
6212 PyObject *swig_obj[1] ;
6213
6214 if (!args) SWIG_fail;
6215 swig_obj[0] = args;
6216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6217 if (!SWIG_IsOK(res1)) {
6218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6219 }
6220 arg1 = reinterpret_cast< wxRect * >(argp1);
6221 {
6222 PyThreadState* __tstate = wxPyBeginAllowThreads();
6223 result = (int)((wxRect const *)arg1)->GetX();
6224 wxPyEndAllowThreads(__tstate);
6225 if (PyErr_Occurred()) SWIG_fail;
6226 }
6227 resultobj = SWIG_From_int(static_cast< int >(result));
6228 return resultobj;
6229 fail:
6230 return NULL;
6231 }
6232
6233
6234 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6235 PyObject *resultobj = 0;
6236 wxRect *arg1 = (wxRect *) 0 ;
6237 int arg2 ;
6238 void *argp1 = 0 ;
6239 int res1 = 0 ;
6240 int val2 ;
6241 int ecode2 = 0 ;
6242 PyObject * obj0 = 0 ;
6243 PyObject * obj1 = 0 ;
6244 char * kwnames[] = {
6245 (char *) "self",(char *) "x", NULL
6246 };
6247
6248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6250 if (!SWIG_IsOK(res1)) {
6251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6252 }
6253 arg1 = reinterpret_cast< wxRect * >(argp1);
6254 ecode2 = SWIG_AsVal_int(obj1, &val2);
6255 if (!SWIG_IsOK(ecode2)) {
6256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6257 }
6258 arg2 = static_cast< int >(val2);
6259 {
6260 PyThreadState* __tstate = wxPyBeginAllowThreads();
6261 (arg1)->SetX(arg2);
6262 wxPyEndAllowThreads(__tstate);
6263 if (PyErr_Occurred()) SWIG_fail;
6264 }
6265 resultobj = SWIG_Py_Void();
6266 return resultobj;
6267 fail:
6268 return NULL;
6269 }
6270
6271
6272 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6273 PyObject *resultobj = 0;
6274 wxRect *arg1 = (wxRect *) 0 ;
6275 int result;
6276 void *argp1 = 0 ;
6277 int res1 = 0 ;
6278 PyObject *swig_obj[1] ;
6279
6280 if (!args) SWIG_fail;
6281 swig_obj[0] = args;
6282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6283 if (!SWIG_IsOK(res1)) {
6284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6285 }
6286 arg1 = reinterpret_cast< wxRect * >(argp1);
6287 {
6288 PyThreadState* __tstate = wxPyBeginAllowThreads();
6289 result = (int)(arg1)->GetY();
6290 wxPyEndAllowThreads(__tstate);
6291 if (PyErr_Occurred()) SWIG_fail;
6292 }
6293 resultobj = SWIG_From_int(static_cast< int >(result));
6294 return resultobj;
6295 fail:
6296 return NULL;
6297 }
6298
6299
6300 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6301 PyObject *resultobj = 0;
6302 wxRect *arg1 = (wxRect *) 0 ;
6303 int arg2 ;
6304 void *argp1 = 0 ;
6305 int res1 = 0 ;
6306 int val2 ;
6307 int ecode2 = 0 ;
6308 PyObject * obj0 = 0 ;
6309 PyObject * obj1 = 0 ;
6310 char * kwnames[] = {
6311 (char *) "self",(char *) "y", NULL
6312 };
6313
6314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6316 if (!SWIG_IsOK(res1)) {
6317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6318 }
6319 arg1 = reinterpret_cast< wxRect * >(argp1);
6320 ecode2 = SWIG_AsVal_int(obj1, &val2);
6321 if (!SWIG_IsOK(ecode2)) {
6322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6323 }
6324 arg2 = static_cast< int >(val2);
6325 {
6326 PyThreadState* __tstate = wxPyBeginAllowThreads();
6327 (arg1)->SetY(arg2);
6328 wxPyEndAllowThreads(__tstate);
6329 if (PyErr_Occurred()) SWIG_fail;
6330 }
6331 resultobj = SWIG_Py_Void();
6332 return resultobj;
6333 fail:
6334 return NULL;
6335 }
6336
6337
6338 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6339 PyObject *resultobj = 0;
6340 wxRect *arg1 = (wxRect *) 0 ;
6341 int result;
6342 void *argp1 = 0 ;
6343 int res1 = 0 ;
6344 PyObject *swig_obj[1] ;
6345
6346 if (!args) SWIG_fail;
6347 swig_obj[0] = args;
6348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6349 if (!SWIG_IsOK(res1)) {
6350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6351 }
6352 arg1 = reinterpret_cast< wxRect * >(argp1);
6353 {
6354 PyThreadState* __tstate = wxPyBeginAllowThreads();
6355 result = (int)((wxRect const *)arg1)->GetWidth();
6356 wxPyEndAllowThreads(__tstate);
6357 if (PyErr_Occurred()) SWIG_fail;
6358 }
6359 resultobj = SWIG_From_int(static_cast< int >(result));
6360 return resultobj;
6361 fail:
6362 return NULL;
6363 }
6364
6365
6366 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6367 PyObject *resultobj = 0;
6368 wxRect *arg1 = (wxRect *) 0 ;
6369 int arg2 ;
6370 void *argp1 = 0 ;
6371 int res1 = 0 ;
6372 int val2 ;
6373 int ecode2 = 0 ;
6374 PyObject * obj0 = 0 ;
6375 PyObject * obj1 = 0 ;
6376 char * kwnames[] = {
6377 (char *) "self",(char *) "w", NULL
6378 };
6379
6380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6382 if (!SWIG_IsOK(res1)) {
6383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6384 }
6385 arg1 = reinterpret_cast< wxRect * >(argp1);
6386 ecode2 = SWIG_AsVal_int(obj1, &val2);
6387 if (!SWIG_IsOK(ecode2)) {
6388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6389 }
6390 arg2 = static_cast< int >(val2);
6391 {
6392 PyThreadState* __tstate = wxPyBeginAllowThreads();
6393 (arg1)->SetWidth(arg2);
6394 wxPyEndAllowThreads(__tstate);
6395 if (PyErr_Occurred()) SWIG_fail;
6396 }
6397 resultobj = SWIG_Py_Void();
6398 return resultobj;
6399 fail:
6400 return NULL;
6401 }
6402
6403
6404 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6405 PyObject *resultobj = 0;
6406 wxRect *arg1 = (wxRect *) 0 ;
6407 int result;
6408 void *argp1 = 0 ;
6409 int res1 = 0 ;
6410 PyObject *swig_obj[1] ;
6411
6412 if (!args) SWIG_fail;
6413 swig_obj[0] = args;
6414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6415 if (!SWIG_IsOK(res1)) {
6416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6417 }
6418 arg1 = reinterpret_cast< wxRect * >(argp1);
6419 {
6420 PyThreadState* __tstate = wxPyBeginAllowThreads();
6421 result = (int)((wxRect const *)arg1)->GetHeight();
6422 wxPyEndAllowThreads(__tstate);
6423 if (PyErr_Occurred()) SWIG_fail;
6424 }
6425 resultobj = SWIG_From_int(static_cast< int >(result));
6426 return resultobj;
6427 fail:
6428 return NULL;
6429 }
6430
6431
6432 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6433 PyObject *resultobj = 0;
6434 wxRect *arg1 = (wxRect *) 0 ;
6435 int arg2 ;
6436 void *argp1 = 0 ;
6437 int res1 = 0 ;
6438 int val2 ;
6439 int ecode2 = 0 ;
6440 PyObject * obj0 = 0 ;
6441 PyObject * obj1 = 0 ;
6442 char * kwnames[] = {
6443 (char *) "self",(char *) "h", NULL
6444 };
6445
6446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6448 if (!SWIG_IsOK(res1)) {
6449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6450 }
6451 arg1 = reinterpret_cast< wxRect * >(argp1);
6452 ecode2 = SWIG_AsVal_int(obj1, &val2);
6453 if (!SWIG_IsOK(ecode2)) {
6454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6455 }
6456 arg2 = static_cast< int >(val2);
6457 {
6458 PyThreadState* __tstate = wxPyBeginAllowThreads();
6459 (arg1)->SetHeight(arg2);
6460 wxPyEndAllowThreads(__tstate);
6461 if (PyErr_Occurred()) SWIG_fail;
6462 }
6463 resultobj = SWIG_Py_Void();
6464 return resultobj;
6465 fail:
6466 return NULL;
6467 }
6468
6469
6470 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6471 PyObject *resultobj = 0;
6472 wxRect *arg1 = (wxRect *) 0 ;
6473 wxPoint result;
6474 void *argp1 = 0 ;
6475 int res1 = 0 ;
6476 PyObject *swig_obj[1] ;
6477
6478 if (!args) SWIG_fail;
6479 swig_obj[0] = args;
6480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6481 if (!SWIG_IsOK(res1)) {
6482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6483 }
6484 arg1 = reinterpret_cast< wxRect * >(argp1);
6485 {
6486 PyThreadState* __tstate = wxPyBeginAllowThreads();
6487 result = ((wxRect const *)arg1)->GetPosition();
6488 wxPyEndAllowThreads(__tstate);
6489 if (PyErr_Occurred()) SWIG_fail;
6490 }
6491 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6492 return resultobj;
6493 fail:
6494 return NULL;
6495 }
6496
6497
6498 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6499 PyObject *resultobj = 0;
6500 wxRect *arg1 = (wxRect *) 0 ;
6501 wxPoint *arg2 = 0 ;
6502 void *argp1 = 0 ;
6503 int res1 = 0 ;
6504 wxPoint temp2 ;
6505 PyObject * obj0 = 0 ;
6506 PyObject * obj1 = 0 ;
6507 char * kwnames[] = {
6508 (char *) "self",(char *) "p", NULL
6509 };
6510
6511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6513 if (!SWIG_IsOK(res1)) {
6514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6515 }
6516 arg1 = reinterpret_cast< wxRect * >(argp1);
6517 {
6518 arg2 = &temp2;
6519 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6520 }
6521 {
6522 PyThreadState* __tstate = wxPyBeginAllowThreads();
6523 (arg1)->SetPosition((wxPoint const &)*arg2);
6524 wxPyEndAllowThreads(__tstate);
6525 if (PyErr_Occurred()) SWIG_fail;
6526 }
6527 resultobj = SWIG_Py_Void();
6528 return resultobj;
6529 fail:
6530 return NULL;
6531 }
6532
6533
6534 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6535 PyObject *resultobj = 0;
6536 wxRect *arg1 = (wxRect *) 0 ;
6537 wxSize result;
6538 void *argp1 = 0 ;
6539 int res1 = 0 ;
6540 PyObject *swig_obj[1] ;
6541
6542 if (!args) SWIG_fail;
6543 swig_obj[0] = args;
6544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6545 if (!SWIG_IsOK(res1)) {
6546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6547 }
6548 arg1 = reinterpret_cast< wxRect * >(argp1);
6549 {
6550 PyThreadState* __tstate = wxPyBeginAllowThreads();
6551 result = ((wxRect const *)arg1)->GetSize();
6552 wxPyEndAllowThreads(__tstate);
6553 if (PyErr_Occurred()) SWIG_fail;
6554 }
6555 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6556 return resultobj;
6557 fail:
6558 return NULL;
6559 }
6560
6561
6562 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6563 PyObject *resultobj = 0;
6564 wxRect *arg1 = (wxRect *) 0 ;
6565 wxSize *arg2 = 0 ;
6566 void *argp1 = 0 ;
6567 int res1 = 0 ;
6568 wxSize temp2 ;
6569 PyObject * obj0 = 0 ;
6570 PyObject * obj1 = 0 ;
6571 char * kwnames[] = {
6572 (char *) "self",(char *) "s", NULL
6573 };
6574
6575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6577 if (!SWIG_IsOK(res1)) {
6578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6579 }
6580 arg1 = reinterpret_cast< wxRect * >(argp1);
6581 {
6582 arg2 = &temp2;
6583 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6584 }
6585 {
6586 PyThreadState* __tstate = wxPyBeginAllowThreads();
6587 (arg1)->SetSize((wxSize const &)*arg2);
6588 wxPyEndAllowThreads(__tstate);
6589 if (PyErr_Occurred()) SWIG_fail;
6590 }
6591 resultobj = SWIG_Py_Void();
6592 return resultobj;
6593 fail:
6594 return NULL;
6595 }
6596
6597
6598 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6599 PyObject *resultobj = 0;
6600 wxRect *arg1 = (wxRect *) 0 ;
6601 bool result;
6602 void *argp1 = 0 ;
6603 int res1 = 0 ;
6604 PyObject *swig_obj[1] ;
6605
6606 if (!args) SWIG_fail;
6607 swig_obj[0] = args;
6608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6609 if (!SWIG_IsOK(res1)) {
6610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6611 }
6612 arg1 = reinterpret_cast< wxRect * >(argp1);
6613 {
6614 PyThreadState* __tstate = wxPyBeginAllowThreads();
6615 result = (bool)((wxRect const *)arg1)->IsEmpty();
6616 wxPyEndAllowThreads(__tstate);
6617 if (PyErr_Occurred()) SWIG_fail;
6618 }
6619 {
6620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6621 }
6622 return resultobj;
6623 fail:
6624 return NULL;
6625 }
6626
6627
6628 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6629 PyObject *resultobj = 0;
6630 wxRect *arg1 = (wxRect *) 0 ;
6631 wxPoint result;
6632 void *argp1 = 0 ;
6633 int res1 = 0 ;
6634 PyObject *swig_obj[1] ;
6635
6636 if (!args) SWIG_fail;
6637 swig_obj[0] = args;
6638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6639 if (!SWIG_IsOK(res1)) {
6640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6641 }
6642 arg1 = reinterpret_cast< wxRect * >(argp1);
6643 {
6644 PyThreadState* __tstate = wxPyBeginAllowThreads();
6645 result = ((wxRect const *)arg1)->GetTopLeft();
6646 wxPyEndAllowThreads(__tstate);
6647 if (PyErr_Occurred()) SWIG_fail;
6648 }
6649 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6650 return resultobj;
6651 fail:
6652 return NULL;
6653 }
6654
6655
6656 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6657 PyObject *resultobj = 0;
6658 wxRect *arg1 = (wxRect *) 0 ;
6659 wxPoint *arg2 = 0 ;
6660 void *argp1 = 0 ;
6661 int res1 = 0 ;
6662 wxPoint temp2 ;
6663 PyObject * obj0 = 0 ;
6664 PyObject * obj1 = 0 ;
6665 char * kwnames[] = {
6666 (char *) "self",(char *) "p", NULL
6667 };
6668
6669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6671 if (!SWIG_IsOK(res1)) {
6672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6673 }
6674 arg1 = reinterpret_cast< wxRect * >(argp1);
6675 {
6676 arg2 = &temp2;
6677 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6678 }
6679 {
6680 PyThreadState* __tstate = wxPyBeginAllowThreads();
6681 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6682 wxPyEndAllowThreads(__tstate);
6683 if (PyErr_Occurred()) SWIG_fail;
6684 }
6685 resultobj = SWIG_Py_Void();
6686 return resultobj;
6687 fail:
6688 return NULL;
6689 }
6690
6691
6692 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6693 PyObject *resultobj = 0;
6694 wxRect *arg1 = (wxRect *) 0 ;
6695 wxPoint result;
6696 void *argp1 = 0 ;
6697 int res1 = 0 ;
6698 PyObject *swig_obj[1] ;
6699
6700 if (!args) SWIG_fail;
6701 swig_obj[0] = args;
6702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6703 if (!SWIG_IsOK(res1)) {
6704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6705 }
6706 arg1 = reinterpret_cast< wxRect * >(argp1);
6707 {
6708 PyThreadState* __tstate = wxPyBeginAllowThreads();
6709 result = ((wxRect const *)arg1)->GetBottomRight();
6710 wxPyEndAllowThreads(__tstate);
6711 if (PyErr_Occurred()) SWIG_fail;
6712 }
6713 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6714 return resultobj;
6715 fail:
6716 return NULL;
6717 }
6718
6719
6720 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6721 PyObject *resultobj = 0;
6722 wxRect *arg1 = (wxRect *) 0 ;
6723 wxPoint *arg2 = 0 ;
6724 void *argp1 = 0 ;
6725 int res1 = 0 ;
6726 wxPoint temp2 ;
6727 PyObject * obj0 = 0 ;
6728 PyObject * obj1 = 0 ;
6729 char * kwnames[] = {
6730 (char *) "self",(char *) "p", NULL
6731 };
6732
6733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6735 if (!SWIG_IsOK(res1)) {
6736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6737 }
6738 arg1 = reinterpret_cast< wxRect * >(argp1);
6739 {
6740 arg2 = &temp2;
6741 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6742 }
6743 {
6744 PyThreadState* __tstate = wxPyBeginAllowThreads();
6745 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6746 wxPyEndAllowThreads(__tstate);
6747 if (PyErr_Occurred()) SWIG_fail;
6748 }
6749 resultobj = SWIG_Py_Void();
6750 return resultobj;
6751 fail:
6752 return NULL;
6753 }
6754
6755
6756 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6757 PyObject *resultobj = 0;
6758 wxRect *arg1 = (wxRect *) 0 ;
6759 int result;
6760 void *argp1 = 0 ;
6761 int res1 = 0 ;
6762 PyObject *swig_obj[1] ;
6763
6764 if (!args) SWIG_fail;
6765 swig_obj[0] = args;
6766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6767 if (!SWIG_IsOK(res1)) {
6768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6769 }
6770 arg1 = reinterpret_cast< wxRect * >(argp1);
6771 {
6772 PyThreadState* __tstate = wxPyBeginAllowThreads();
6773 result = (int)((wxRect const *)arg1)->GetLeft();
6774 wxPyEndAllowThreads(__tstate);
6775 if (PyErr_Occurred()) SWIG_fail;
6776 }
6777 resultobj = SWIG_From_int(static_cast< int >(result));
6778 return resultobj;
6779 fail:
6780 return NULL;
6781 }
6782
6783
6784 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6785 PyObject *resultobj = 0;
6786 wxRect *arg1 = (wxRect *) 0 ;
6787 int result;
6788 void *argp1 = 0 ;
6789 int res1 = 0 ;
6790 PyObject *swig_obj[1] ;
6791
6792 if (!args) SWIG_fail;
6793 swig_obj[0] = args;
6794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6795 if (!SWIG_IsOK(res1)) {
6796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6797 }
6798 arg1 = reinterpret_cast< wxRect * >(argp1);
6799 {
6800 PyThreadState* __tstate = wxPyBeginAllowThreads();
6801 result = (int)((wxRect const *)arg1)->GetTop();
6802 wxPyEndAllowThreads(__tstate);
6803 if (PyErr_Occurred()) SWIG_fail;
6804 }
6805 resultobj = SWIG_From_int(static_cast< int >(result));
6806 return resultobj;
6807 fail:
6808 return NULL;
6809 }
6810
6811
6812 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6813 PyObject *resultobj = 0;
6814 wxRect *arg1 = (wxRect *) 0 ;
6815 int result;
6816 void *argp1 = 0 ;
6817 int res1 = 0 ;
6818 PyObject *swig_obj[1] ;
6819
6820 if (!args) SWIG_fail;
6821 swig_obj[0] = args;
6822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6823 if (!SWIG_IsOK(res1)) {
6824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6825 }
6826 arg1 = reinterpret_cast< wxRect * >(argp1);
6827 {
6828 PyThreadState* __tstate = wxPyBeginAllowThreads();
6829 result = (int)((wxRect const *)arg1)->GetBottom();
6830 wxPyEndAllowThreads(__tstate);
6831 if (PyErr_Occurred()) SWIG_fail;
6832 }
6833 resultobj = SWIG_From_int(static_cast< int >(result));
6834 return resultobj;
6835 fail:
6836 return NULL;
6837 }
6838
6839
6840 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6841 PyObject *resultobj = 0;
6842 wxRect *arg1 = (wxRect *) 0 ;
6843 int result;
6844 void *argp1 = 0 ;
6845 int res1 = 0 ;
6846 PyObject *swig_obj[1] ;
6847
6848 if (!args) SWIG_fail;
6849 swig_obj[0] = args;
6850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6851 if (!SWIG_IsOK(res1)) {
6852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6853 }
6854 arg1 = reinterpret_cast< wxRect * >(argp1);
6855 {
6856 PyThreadState* __tstate = wxPyBeginAllowThreads();
6857 result = (int)((wxRect const *)arg1)->GetRight();
6858 wxPyEndAllowThreads(__tstate);
6859 if (PyErr_Occurred()) SWIG_fail;
6860 }
6861 resultobj = SWIG_From_int(static_cast< int >(result));
6862 return resultobj;
6863 fail:
6864 return NULL;
6865 }
6866
6867
6868 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6869 PyObject *resultobj = 0;
6870 wxRect *arg1 = (wxRect *) 0 ;
6871 int arg2 ;
6872 void *argp1 = 0 ;
6873 int res1 = 0 ;
6874 int val2 ;
6875 int ecode2 = 0 ;
6876 PyObject * obj0 = 0 ;
6877 PyObject * obj1 = 0 ;
6878 char * kwnames[] = {
6879 (char *) "self",(char *) "left", NULL
6880 };
6881
6882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6884 if (!SWIG_IsOK(res1)) {
6885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6886 }
6887 arg1 = reinterpret_cast< wxRect * >(argp1);
6888 ecode2 = SWIG_AsVal_int(obj1, &val2);
6889 if (!SWIG_IsOK(ecode2)) {
6890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6891 }
6892 arg2 = static_cast< int >(val2);
6893 {
6894 PyThreadState* __tstate = wxPyBeginAllowThreads();
6895 (arg1)->SetLeft(arg2);
6896 wxPyEndAllowThreads(__tstate);
6897 if (PyErr_Occurred()) SWIG_fail;
6898 }
6899 resultobj = SWIG_Py_Void();
6900 return resultobj;
6901 fail:
6902 return NULL;
6903 }
6904
6905
6906 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6907 PyObject *resultobj = 0;
6908 wxRect *arg1 = (wxRect *) 0 ;
6909 int arg2 ;
6910 void *argp1 = 0 ;
6911 int res1 = 0 ;
6912 int val2 ;
6913 int ecode2 = 0 ;
6914 PyObject * obj0 = 0 ;
6915 PyObject * obj1 = 0 ;
6916 char * kwnames[] = {
6917 (char *) "self",(char *) "right", NULL
6918 };
6919
6920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6922 if (!SWIG_IsOK(res1)) {
6923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6924 }
6925 arg1 = reinterpret_cast< wxRect * >(argp1);
6926 ecode2 = SWIG_AsVal_int(obj1, &val2);
6927 if (!SWIG_IsOK(ecode2)) {
6928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6929 }
6930 arg2 = static_cast< int >(val2);
6931 {
6932 PyThreadState* __tstate = wxPyBeginAllowThreads();
6933 (arg1)->SetRight(arg2);
6934 wxPyEndAllowThreads(__tstate);
6935 if (PyErr_Occurred()) SWIG_fail;
6936 }
6937 resultobj = SWIG_Py_Void();
6938 return resultobj;
6939 fail:
6940 return NULL;
6941 }
6942
6943
6944 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6945 PyObject *resultobj = 0;
6946 wxRect *arg1 = (wxRect *) 0 ;
6947 int arg2 ;
6948 void *argp1 = 0 ;
6949 int res1 = 0 ;
6950 int val2 ;
6951 int ecode2 = 0 ;
6952 PyObject * obj0 = 0 ;
6953 PyObject * obj1 = 0 ;
6954 char * kwnames[] = {
6955 (char *) "self",(char *) "top", NULL
6956 };
6957
6958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6960 if (!SWIG_IsOK(res1)) {
6961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6962 }
6963 arg1 = reinterpret_cast< wxRect * >(argp1);
6964 ecode2 = SWIG_AsVal_int(obj1, &val2);
6965 if (!SWIG_IsOK(ecode2)) {
6966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6967 }
6968 arg2 = static_cast< int >(val2);
6969 {
6970 PyThreadState* __tstate = wxPyBeginAllowThreads();
6971 (arg1)->SetTop(arg2);
6972 wxPyEndAllowThreads(__tstate);
6973 if (PyErr_Occurred()) SWIG_fail;
6974 }
6975 resultobj = SWIG_Py_Void();
6976 return resultobj;
6977 fail:
6978 return NULL;
6979 }
6980
6981
6982 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6983 PyObject *resultobj = 0;
6984 wxRect *arg1 = (wxRect *) 0 ;
6985 int arg2 ;
6986 void *argp1 = 0 ;
6987 int res1 = 0 ;
6988 int val2 ;
6989 int ecode2 = 0 ;
6990 PyObject * obj0 = 0 ;
6991 PyObject * obj1 = 0 ;
6992 char * kwnames[] = {
6993 (char *) "self",(char *) "bottom", NULL
6994 };
6995
6996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6998 if (!SWIG_IsOK(res1)) {
6999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7000 }
7001 arg1 = reinterpret_cast< wxRect * >(argp1);
7002 ecode2 = SWIG_AsVal_int(obj1, &val2);
7003 if (!SWIG_IsOK(ecode2)) {
7004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7005 }
7006 arg2 = static_cast< int >(val2);
7007 {
7008 PyThreadState* __tstate = wxPyBeginAllowThreads();
7009 (arg1)->SetBottom(arg2);
7010 wxPyEndAllowThreads(__tstate);
7011 if (PyErr_Occurred()) SWIG_fail;
7012 }
7013 resultobj = SWIG_Py_Void();
7014 return resultobj;
7015 fail:
7016 return NULL;
7017 }
7018
7019
7020 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7021 PyObject *resultobj = 0;
7022 wxRect *arg1 = (wxRect *) 0 ;
7023 int arg2 ;
7024 int arg3 ;
7025 wxRect *result = 0 ;
7026 void *argp1 = 0 ;
7027 int res1 = 0 ;
7028 int val2 ;
7029 int ecode2 = 0 ;
7030 int val3 ;
7031 int ecode3 = 0 ;
7032 PyObject * obj0 = 0 ;
7033 PyObject * obj1 = 0 ;
7034 PyObject * obj2 = 0 ;
7035 char * kwnames[] = {
7036 (char *) "self",(char *) "dx",(char *) "dy", NULL
7037 };
7038
7039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7041 if (!SWIG_IsOK(res1)) {
7042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7043 }
7044 arg1 = reinterpret_cast< wxRect * >(argp1);
7045 ecode2 = SWIG_AsVal_int(obj1, &val2);
7046 if (!SWIG_IsOK(ecode2)) {
7047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7048 }
7049 arg2 = static_cast< int >(val2);
7050 ecode3 = SWIG_AsVal_int(obj2, &val3);
7051 if (!SWIG_IsOK(ecode3)) {
7052 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7053 }
7054 arg3 = static_cast< int >(val3);
7055 {
7056 PyThreadState* __tstate = wxPyBeginAllowThreads();
7057 {
7058 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7059 result = (wxRect *) &_result_ref;
7060 }
7061 wxPyEndAllowThreads(__tstate);
7062 if (PyErr_Occurred()) SWIG_fail;
7063 }
7064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7065 return resultobj;
7066 fail:
7067 return NULL;
7068 }
7069
7070
7071 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7072 PyObject *resultobj = 0;
7073 wxRect *arg1 = (wxRect *) 0 ;
7074 int arg2 ;
7075 int arg3 ;
7076 wxRect *result = 0 ;
7077 void *argp1 = 0 ;
7078 int res1 = 0 ;
7079 int val2 ;
7080 int ecode2 = 0 ;
7081 int val3 ;
7082 int ecode3 = 0 ;
7083 PyObject * obj0 = 0 ;
7084 PyObject * obj1 = 0 ;
7085 PyObject * obj2 = 0 ;
7086 char * kwnames[] = {
7087 (char *) "self",(char *) "dx",(char *) "dy", NULL
7088 };
7089
7090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7092 if (!SWIG_IsOK(res1)) {
7093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7094 }
7095 arg1 = reinterpret_cast< wxRect * >(argp1);
7096 ecode2 = SWIG_AsVal_int(obj1, &val2);
7097 if (!SWIG_IsOK(ecode2)) {
7098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7099 }
7100 arg2 = static_cast< int >(val2);
7101 ecode3 = SWIG_AsVal_int(obj2, &val3);
7102 if (!SWIG_IsOK(ecode3)) {
7103 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7104 }
7105 arg3 = static_cast< int >(val3);
7106 {
7107 PyThreadState* __tstate = wxPyBeginAllowThreads();
7108 {
7109 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7110 result = (wxRect *) &_result_ref;
7111 }
7112 wxPyEndAllowThreads(__tstate);
7113 if (PyErr_Occurred()) SWIG_fail;
7114 }
7115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7116 return resultobj;
7117 fail:
7118 return NULL;
7119 }
7120
7121
7122 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7123 PyObject *resultobj = 0;
7124 wxRect *arg1 = (wxRect *) 0 ;
7125 int arg2 ;
7126 int arg3 ;
7127 void *argp1 = 0 ;
7128 int res1 = 0 ;
7129 int val2 ;
7130 int ecode2 = 0 ;
7131 int val3 ;
7132 int ecode3 = 0 ;
7133 PyObject * obj0 = 0 ;
7134 PyObject * obj1 = 0 ;
7135 PyObject * obj2 = 0 ;
7136 char * kwnames[] = {
7137 (char *) "self",(char *) "dx",(char *) "dy", NULL
7138 };
7139
7140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7142 if (!SWIG_IsOK(res1)) {
7143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7144 }
7145 arg1 = reinterpret_cast< wxRect * >(argp1);
7146 ecode2 = SWIG_AsVal_int(obj1, &val2);
7147 if (!SWIG_IsOK(ecode2)) {
7148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7149 }
7150 arg2 = static_cast< int >(val2);
7151 ecode3 = SWIG_AsVal_int(obj2, &val3);
7152 if (!SWIG_IsOK(ecode3)) {
7153 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7154 }
7155 arg3 = static_cast< int >(val3);
7156 {
7157 PyThreadState* __tstate = wxPyBeginAllowThreads();
7158 (arg1)->Offset(arg2,arg3);
7159 wxPyEndAllowThreads(__tstate);
7160 if (PyErr_Occurred()) SWIG_fail;
7161 }
7162 resultobj = SWIG_Py_Void();
7163 return resultobj;
7164 fail:
7165 return NULL;
7166 }
7167
7168
7169 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7170 PyObject *resultobj = 0;
7171 wxRect *arg1 = (wxRect *) 0 ;
7172 wxPoint *arg2 = 0 ;
7173 void *argp1 = 0 ;
7174 int res1 = 0 ;
7175 wxPoint temp2 ;
7176 PyObject * obj0 = 0 ;
7177 PyObject * obj1 = 0 ;
7178 char * kwnames[] = {
7179 (char *) "self",(char *) "pt", NULL
7180 };
7181
7182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7184 if (!SWIG_IsOK(res1)) {
7185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7186 }
7187 arg1 = reinterpret_cast< wxRect * >(argp1);
7188 {
7189 arg2 = &temp2;
7190 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7191 }
7192 {
7193 PyThreadState* __tstate = wxPyBeginAllowThreads();
7194 (arg1)->Offset((wxPoint const &)*arg2);
7195 wxPyEndAllowThreads(__tstate);
7196 if (PyErr_Occurred()) SWIG_fail;
7197 }
7198 resultobj = SWIG_Py_Void();
7199 return resultobj;
7200 fail:
7201 return NULL;
7202 }
7203
7204
7205 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7206 PyObject *resultobj = 0;
7207 wxRect *arg1 = (wxRect *) 0 ;
7208 wxRect *arg2 = 0 ;
7209 wxRect result;
7210 void *argp1 = 0 ;
7211 int res1 = 0 ;
7212 wxRect temp2 ;
7213 PyObject * obj0 = 0 ;
7214 PyObject * obj1 = 0 ;
7215 char * kwnames[] = {
7216 (char *) "self",(char *) "rect", NULL
7217 };
7218
7219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7221 if (!SWIG_IsOK(res1)) {
7222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7223 }
7224 arg1 = reinterpret_cast< wxRect * >(argp1);
7225 {
7226 arg2 = &temp2;
7227 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7228 }
7229 {
7230 PyThreadState* __tstate = wxPyBeginAllowThreads();
7231 result = (arg1)->Intersect((wxRect const &)*arg2);
7232 wxPyEndAllowThreads(__tstate);
7233 if (PyErr_Occurred()) SWIG_fail;
7234 }
7235 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7236 return resultobj;
7237 fail:
7238 return NULL;
7239 }
7240
7241
7242 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7243 PyObject *resultobj = 0;
7244 wxRect *arg1 = (wxRect *) 0 ;
7245 wxRect *arg2 = 0 ;
7246 wxRect result;
7247 void *argp1 = 0 ;
7248 int res1 = 0 ;
7249 wxRect temp2 ;
7250 PyObject * obj0 = 0 ;
7251 PyObject * obj1 = 0 ;
7252 char * kwnames[] = {
7253 (char *) "self",(char *) "rect", NULL
7254 };
7255
7256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7258 if (!SWIG_IsOK(res1)) {
7259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7260 }
7261 arg1 = reinterpret_cast< wxRect * >(argp1);
7262 {
7263 arg2 = &temp2;
7264 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7265 }
7266 {
7267 PyThreadState* __tstate = wxPyBeginAllowThreads();
7268 result = (arg1)->Union((wxRect const &)*arg2);
7269 wxPyEndAllowThreads(__tstate);
7270 if (PyErr_Occurred()) SWIG_fail;
7271 }
7272 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7273 return resultobj;
7274 fail:
7275 return NULL;
7276 }
7277
7278
7279 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7280 PyObject *resultobj = 0;
7281 wxRect *arg1 = (wxRect *) 0 ;
7282 wxRect *arg2 = 0 ;
7283 wxRect result;
7284 void *argp1 = 0 ;
7285 int res1 = 0 ;
7286 wxRect temp2 ;
7287 PyObject * obj0 = 0 ;
7288 PyObject * obj1 = 0 ;
7289 char * kwnames[] = {
7290 (char *) "self",(char *) "rect", NULL
7291 };
7292
7293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7295 if (!SWIG_IsOK(res1)) {
7296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7297 }
7298 arg1 = reinterpret_cast< wxRect * >(argp1);
7299 {
7300 arg2 = &temp2;
7301 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7302 }
7303 {
7304 PyThreadState* __tstate = wxPyBeginAllowThreads();
7305 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7306 wxPyEndAllowThreads(__tstate);
7307 if (PyErr_Occurred()) SWIG_fail;
7308 }
7309 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7310 return resultobj;
7311 fail:
7312 return NULL;
7313 }
7314
7315
7316 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7317 PyObject *resultobj = 0;
7318 wxRect *arg1 = (wxRect *) 0 ;
7319 wxRect *arg2 = 0 ;
7320 wxRect *result = 0 ;
7321 void *argp1 = 0 ;
7322 int res1 = 0 ;
7323 wxRect temp2 ;
7324 PyObject * obj0 = 0 ;
7325 PyObject * obj1 = 0 ;
7326 char * kwnames[] = {
7327 (char *) "self",(char *) "rect", NULL
7328 };
7329
7330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7332 if (!SWIG_IsOK(res1)) {
7333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7334 }
7335 arg1 = reinterpret_cast< wxRect * >(argp1);
7336 {
7337 arg2 = &temp2;
7338 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7339 }
7340 {
7341 PyThreadState* __tstate = wxPyBeginAllowThreads();
7342 {
7343 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7344 result = (wxRect *) &_result_ref;
7345 }
7346 wxPyEndAllowThreads(__tstate);
7347 if (PyErr_Occurred()) SWIG_fail;
7348 }
7349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7350 return resultobj;
7351 fail:
7352 return NULL;
7353 }
7354
7355
7356 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7357 PyObject *resultobj = 0;
7358 wxRect *arg1 = (wxRect *) 0 ;
7359 PyObject *arg2 = (PyObject *) 0 ;
7360 bool result;
7361 void *argp1 = 0 ;
7362 int res1 = 0 ;
7363 PyObject * obj0 = 0 ;
7364 PyObject * obj1 = 0 ;
7365 char * kwnames[] = {
7366 (char *) "self",(char *) "other", NULL
7367 };
7368
7369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7371 if (!SWIG_IsOK(res1)) {
7372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7373 }
7374 arg1 = reinterpret_cast< wxRect * >(argp1);
7375 arg2 = obj1;
7376 {
7377 result = (bool)wxRect___eq__(arg1,arg2);
7378 if (PyErr_Occurred()) SWIG_fail;
7379 }
7380 {
7381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7382 }
7383 return resultobj;
7384 fail:
7385 return NULL;
7386 }
7387
7388
7389 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7390 PyObject *resultobj = 0;
7391 wxRect *arg1 = (wxRect *) 0 ;
7392 PyObject *arg2 = (PyObject *) 0 ;
7393 bool result;
7394 void *argp1 = 0 ;
7395 int res1 = 0 ;
7396 PyObject * obj0 = 0 ;
7397 PyObject * obj1 = 0 ;
7398 char * kwnames[] = {
7399 (char *) "self",(char *) "other", NULL
7400 };
7401
7402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7404 if (!SWIG_IsOK(res1)) {
7405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7406 }
7407 arg1 = reinterpret_cast< wxRect * >(argp1);
7408 arg2 = obj1;
7409 {
7410 result = (bool)wxRect___ne__(arg1,arg2);
7411 if (PyErr_Occurred()) SWIG_fail;
7412 }
7413 {
7414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7415 }
7416 return resultobj;
7417 fail:
7418 return NULL;
7419 }
7420
7421
7422 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7423 PyObject *resultobj = 0;
7424 wxRect *arg1 = (wxRect *) 0 ;
7425 int arg2 ;
7426 int arg3 ;
7427 bool result;
7428 void *argp1 = 0 ;
7429 int res1 = 0 ;
7430 int val2 ;
7431 int ecode2 = 0 ;
7432 int val3 ;
7433 int ecode3 = 0 ;
7434 PyObject * obj0 = 0 ;
7435 PyObject * obj1 = 0 ;
7436 PyObject * obj2 = 0 ;
7437 char * kwnames[] = {
7438 (char *) "self",(char *) "x",(char *) "y", NULL
7439 };
7440
7441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7443 if (!SWIG_IsOK(res1)) {
7444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7445 }
7446 arg1 = reinterpret_cast< wxRect * >(argp1);
7447 ecode2 = SWIG_AsVal_int(obj1, &val2);
7448 if (!SWIG_IsOK(ecode2)) {
7449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7450 }
7451 arg2 = static_cast< int >(val2);
7452 ecode3 = SWIG_AsVal_int(obj2, &val3);
7453 if (!SWIG_IsOK(ecode3)) {
7454 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7455 }
7456 arg3 = static_cast< int >(val3);
7457 {
7458 PyThreadState* __tstate = wxPyBeginAllowThreads();
7459 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7460 wxPyEndAllowThreads(__tstate);
7461 if (PyErr_Occurred()) SWIG_fail;
7462 }
7463 {
7464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7465 }
7466 return resultobj;
7467 fail:
7468 return NULL;
7469 }
7470
7471
7472 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7473 PyObject *resultobj = 0;
7474 wxRect *arg1 = (wxRect *) 0 ;
7475 wxPoint *arg2 = 0 ;
7476 bool result;
7477 void *argp1 = 0 ;
7478 int res1 = 0 ;
7479 wxPoint temp2 ;
7480 PyObject * obj0 = 0 ;
7481 PyObject * obj1 = 0 ;
7482 char * kwnames[] = {
7483 (char *) "self",(char *) "pt", NULL
7484 };
7485
7486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7488 if (!SWIG_IsOK(res1)) {
7489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7490 }
7491 arg1 = reinterpret_cast< wxRect * >(argp1);
7492 {
7493 arg2 = &temp2;
7494 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7495 }
7496 {
7497 PyThreadState* __tstate = wxPyBeginAllowThreads();
7498 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7499 wxPyEndAllowThreads(__tstate);
7500 if (PyErr_Occurred()) SWIG_fail;
7501 }
7502 {
7503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7504 }
7505 return resultobj;
7506 fail:
7507 return NULL;
7508 }
7509
7510
7511 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7512 PyObject *resultobj = 0;
7513 wxRect *arg1 = (wxRect *) 0 ;
7514 wxRect *arg2 = 0 ;
7515 bool result;
7516 void *argp1 = 0 ;
7517 int res1 = 0 ;
7518 wxRect temp2 ;
7519 PyObject * obj0 = 0 ;
7520 PyObject * obj1 = 0 ;
7521 char * kwnames[] = {
7522 (char *) "self",(char *) "rect", NULL
7523 };
7524
7525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7527 if (!SWIG_IsOK(res1)) {
7528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7529 }
7530 arg1 = reinterpret_cast< wxRect * >(argp1);
7531 {
7532 arg2 = &temp2;
7533 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7534 }
7535 {
7536 PyThreadState* __tstate = wxPyBeginAllowThreads();
7537 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7538 wxPyEndAllowThreads(__tstate);
7539 if (PyErr_Occurred()) SWIG_fail;
7540 }
7541 {
7542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7543 }
7544 return resultobj;
7545 fail:
7546 return NULL;
7547 }
7548
7549
7550 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7551 PyObject *resultobj = 0;
7552 wxRect *arg1 = (wxRect *) 0 ;
7553 wxRect *arg2 = 0 ;
7554 int arg3 = (int) wxBOTH ;
7555 wxRect result;
7556 void *argp1 = 0 ;
7557 int res1 = 0 ;
7558 wxRect temp2 ;
7559 int val3 ;
7560 int ecode3 = 0 ;
7561 PyObject * obj0 = 0 ;
7562 PyObject * obj1 = 0 ;
7563 PyObject * obj2 = 0 ;
7564 char * kwnames[] = {
7565 (char *) "self",(char *) "r",(char *) "dir", NULL
7566 };
7567
7568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7570 if (!SWIG_IsOK(res1)) {
7571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7572 }
7573 arg1 = reinterpret_cast< wxRect * >(argp1);
7574 {
7575 arg2 = &temp2;
7576 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7577 }
7578 if (obj2) {
7579 ecode3 = SWIG_AsVal_int(obj2, &val3);
7580 if (!SWIG_IsOK(ecode3)) {
7581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7582 }
7583 arg3 = static_cast< int >(val3);
7584 }
7585 {
7586 PyThreadState* __tstate = wxPyBeginAllowThreads();
7587 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7588 wxPyEndAllowThreads(__tstate);
7589 if (PyErr_Occurred()) SWIG_fail;
7590 }
7591 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7592 return resultobj;
7593 fail:
7594 return NULL;
7595 }
7596
7597
7598 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7599 PyObject *resultobj = 0;
7600 wxRect *arg1 = (wxRect *) 0 ;
7601 int arg2 ;
7602 void *argp1 = 0 ;
7603 int res1 = 0 ;
7604 int val2 ;
7605 int ecode2 = 0 ;
7606 PyObject *swig_obj[2] ;
7607
7608 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7610 if (!SWIG_IsOK(res1)) {
7611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7612 }
7613 arg1 = reinterpret_cast< wxRect * >(argp1);
7614 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7615 if (!SWIG_IsOK(ecode2)) {
7616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7617 }
7618 arg2 = static_cast< int >(val2);
7619 if (arg1) (arg1)->x = arg2;
7620
7621 resultobj = SWIG_Py_Void();
7622 return resultobj;
7623 fail:
7624 return NULL;
7625 }
7626
7627
7628 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7629 PyObject *resultobj = 0;
7630 wxRect *arg1 = (wxRect *) 0 ;
7631 int result;
7632 void *argp1 = 0 ;
7633 int res1 = 0 ;
7634 PyObject *swig_obj[1] ;
7635
7636 if (!args) SWIG_fail;
7637 swig_obj[0] = args;
7638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7639 if (!SWIG_IsOK(res1)) {
7640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7641 }
7642 arg1 = reinterpret_cast< wxRect * >(argp1);
7643 result = (int) ((arg1)->x);
7644 resultobj = SWIG_From_int(static_cast< int >(result));
7645 return resultobj;
7646 fail:
7647 return NULL;
7648 }
7649
7650
7651 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7652 PyObject *resultobj = 0;
7653 wxRect *arg1 = (wxRect *) 0 ;
7654 int arg2 ;
7655 void *argp1 = 0 ;
7656 int res1 = 0 ;
7657 int val2 ;
7658 int ecode2 = 0 ;
7659 PyObject *swig_obj[2] ;
7660
7661 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7663 if (!SWIG_IsOK(res1)) {
7664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7665 }
7666 arg1 = reinterpret_cast< wxRect * >(argp1);
7667 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7668 if (!SWIG_IsOK(ecode2)) {
7669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7670 }
7671 arg2 = static_cast< int >(val2);
7672 if (arg1) (arg1)->y = arg2;
7673
7674 resultobj = SWIG_Py_Void();
7675 return resultobj;
7676 fail:
7677 return NULL;
7678 }
7679
7680
7681 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7682 PyObject *resultobj = 0;
7683 wxRect *arg1 = (wxRect *) 0 ;
7684 int result;
7685 void *argp1 = 0 ;
7686 int res1 = 0 ;
7687 PyObject *swig_obj[1] ;
7688
7689 if (!args) SWIG_fail;
7690 swig_obj[0] = args;
7691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7692 if (!SWIG_IsOK(res1)) {
7693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7694 }
7695 arg1 = reinterpret_cast< wxRect * >(argp1);
7696 result = (int) ((arg1)->y);
7697 resultobj = SWIG_From_int(static_cast< int >(result));
7698 return resultobj;
7699 fail:
7700 return NULL;
7701 }
7702
7703
7704 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7705 PyObject *resultobj = 0;
7706 wxRect *arg1 = (wxRect *) 0 ;
7707 int arg2 ;
7708 void *argp1 = 0 ;
7709 int res1 = 0 ;
7710 int val2 ;
7711 int ecode2 = 0 ;
7712 PyObject *swig_obj[2] ;
7713
7714 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7716 if (!SWIG_IsOK(res1)) {
7717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7718 }
7719 arg1 = reinterpret_cast< wxRect * >(argp1);
7720 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7721 if (!SWIG_IsOK(ecode2)) {
7722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7723 }
7724 arg2 = static_cast< int >(val2);
7725 if (arg1) (arg1)->width = arg2;
7726
7727 resultobj = SWIG_Py_Void();
7728 return resultobj;
7729 fail:
7730 return NULL;
7731 }
7732
7733
7734 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7735 PyObject *resultobj = 0;
7736 wxRect *arg1 = (wxRect *) 0 ;
7737 int result;
7738 void *argp1 = 0 ;
7739 int res1 = 0 ;
7740 PyObject *swig_obj[1] ;
7741
7742 if (!args) SWIG_fail;
7743 swig_obj[0] = args;
7744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7745 if (!SWIG_IsOK(res1)) {
7746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7747 }
7748 arg1 = reinterpret_cast< wxRect * >(argp1);
7749 result = (int) ((arg1)->width);
7750 resultobj = SWIG_From_int(static_cast< int >(result));
7751 return resultobj;
7752 fail:
7753 return NULL;
7754 }
7755
7756
7757 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7758 PyObject *resultobj = 0;
7759 wxRect *arg1 = (wxRect *) 0 ;
7760 int arg2 ;
7761 void *argp1 = 0 ;
7762 int res1 = 0 ;
7763 int val2 ;
7764 int ecode2 = 0 ;
7765 PyObject *swig_obj[2] ;
7766
7767 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7769 if (!SWIG_IsOK(res1)) {
7770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7771 }
7772 arg1 = reinterpret_cast< wxRect * >(argp1);
7773 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7774 if (!SWIG_IsOK(ecode2)) {
7775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7776 }
7777 arg2 = static_cast< int >(val2);
7778 if (arg1) (arg1)->height = arg2;
7779
7780 resultobj = SWIG_Py_Void();
7781 return resultobj;
7782 fail:
7783 return NULL;
7784 }
7785
7786
7787 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7788 PyObject *resultobj = 0;
7789 wxRect *arg1 = (wxRect *) 0 ;
7790 int result;
7791 void *argp1 = 0 ;
7792 int res1 = 0 ;
7793 PyObject *swig_obj[1] ;
7794
7795 if (!args) SWIG_fail;
7796 swig_obj[0] = args;
7797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7798 if (!SWIG_IsOK(res1)) {
7799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7800 }
7801 arg1 = reinterpret_cast< wxRect * >(argp1);
7802 result = (int) ((arg1)->height);
7803 resultobj = SWIG_From_int(static_cast< int >(result));
7804 return resultobj;
7805 fail:
7806 return NULL;
7807 }
7808
7809
7810 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7811 PyObject *resultobj = 0;
7812 wxRect *arg1 = (wxRect *) 0 ;
7813 int arg2 = (int) 0 ;
7814 int arg3 = (int) 0 ;
7815 int arg4 = (int) 0 ;
7816 int arg5 = (int) 0 ;
7817 void *argp1 = 0 ;
7818 int res1 = 0 ;
7819 int val2 ;
7820 int ecode2 = 0 ;
7821 int val3 ;
7822 int ecode3 = 0 ;
7823 int val4 ;
7824 int ecode4 = 0 ;
7825 int val5 ;
7826 int ecode5 = 0 ;
7827 PyObject * obj0 = 0 ;
7828 PyObject * obj1 = 0 ;
7829 PyObject * obj2 = 0 ;
7830 PyObject * obj3 = 0 ;
7831 PyObject * obj4 = 0 ;
7832 char * kwnames[] = {
7833 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7834 };
7835
7836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7838 if (!SWIG_IsOK(res1)) {
7839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7840 }
7841 arg1 = reinterpret_cast< wxRect * >(argp1);
7842 if (obj1) {
7843 ecode2 = SWIG_AsVal_int(obj1, &val2);
7844 if (!SWIG_IsOK(ecode2)) {
7845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7846 }
7847 arg2 = static_cast< int >(val2);
7848 }
7849 if (obj2) {
7850 ecode3 = SWIG_AsVal_int(obj2, &val3);
7851 if (!SWIG_IsOK(ecode3)) {
7852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7853 }
7854 arg3 = static_cast< int >(val3);
7855 }
7856 if (obj3) {
7857 ecode4 = SWIG_AsVal_int(obj3, &val4);
7858 if (!SWIG_IsOK(ecode4)) {
7859 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7860 }
7861 arg4 = static_cast< int >(val4);
7862 }
7863 if (obj4) {
7864 ecode5 = SWIG_AsVal_int(obj4, &val5);
7865 if (!SWIG_IsOK(ecode5)) {
7866 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7867 }
7868 arg5 = static_cast< int >(val5);
7869 }
7870 {
7871 PyThreadState* __tstate = wxPyBeginAllowThreads();
7872 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7873 wxPyEndAllowThreads(__tstate);
7874 if (PyErr_Occurred()) SWIG_fail;
7875 }
7876 resultobj = SWIG_Py_Void();
7877 return resultobj;
7878 fail:
7879 return NULL;
7880 }
7881
7882
7883 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7884 PyObject *resultobj = 0;
7885 wxRect *arg1 = (wxRect *) 0 ;
7886 PyObject *result = 0 ;
7887 void *argp1 = 0 ;
7888 int res1 = 0 ;
7889 PyObject *swig_obj[1] ;
7890
7891 if (!args) SWIG_fail;
7892 swig_obj[0] = args;
7893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7894 if (!SWIG_IsOK(res1)) {
7895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7896 }
7897 arg1 = reinterpret_cast< wxRect * >(argp1);
7898 {
7899 PyThreadState* __tstate = wxPyBeginAllowThreads();
7900 result = (PyObject *)wxRect_Get(arg1);
7901 wxPyEndAllowThreads(__tstate);
7902 if (PyErr_Occurred()) SWIG_fail;
7903 }
7904 resultobj = result;
7905 return resultobj;
7906 fail:
7907 return NULL;
7908 }
7909
7910
7911 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7912 PyObject *obj;
7913 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7914 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7915 return SWIG_Py_Void();
7916 }
7917
7918 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7919 return SWIG_Python_InitShadowInstance(args);
7920 }
7921
7922 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7923 PyObject *resultobj = 0;
7924 wxRect *arg1 = (wxRect *) 0 ;
7925 wxRect *arg2 = (wxRect *) 0 ;
7926 PyObject *result = 0 ;
7927 void *argp1 = 0 ;
7928 int res1 = 0 ;
7929 void *argp2 = 0 ;
7930 int res2 = 0 ;
7931 PyObject * obj0 = 0 ;
7932 PyObject * obj1 = 0 ;
7933 char * kwnames[] = {
7934 (char *) "r1",(char *) "r2", NULL
7935 };
7936
7937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7939 if (!SWIG_IsOK(res1)) {
7940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7941 }
7942 arg1 = reinterpret_cast< wxRect * >(argp1);
7943 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7944 if (!SWIG_IsOK(res2)) {
7945 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7946 }
7947 arg2 = reinterpret_cast< wxRect * >(argp2);
7948 {
7949 if (!wxPyCheckForApp()) SWIG_fail;
7950 PyThreadState* __tstate = wxPyBeginAllowThreads();
7951 result = (PyObject *)wxIntersectRect(arg1,arg2);
7952 wxPyEndAllowThreads(__tstate);
7953 if (PyErr_Occurred()) SWIG_fail;
7954 }
7955 resultobj = result;
7956 return resultobj;
7957 fail:
7958 return NULL;
7959 }
7960
7961
7962 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7963 PyObject *resultobj = 0;
7964 double arg1 = (double) 0.0 ;
7965 double arg2 = (double) 0.0 ;
7966 wxPoint2D *result = 0 ;
7967 double val1 ;
7968 int ecode1 = 0 ;
7969 double val2 ;
7970 int ecode2 = 0 ;
7971 PyObject * obj0 = 0 ;
7972 PyObject * obj1 = 0 ;
7973 char * kwnames[] = {
7974 (char *) "x",(char *) "y", NULL
7975 };
7976
7977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7978 if (obj0) {
7979 ecode1 = SWIG_AsVal_double(obj0, &val1);
7980 if (!SWIG_IsOK(ecode1)) {
7981 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7982 }
7983 arg1 = static_cast< double >(val1);
7984 }
7985 if (obj1) {
7986 ecode2 = SWIG_AsVal_double(obj1, &val2);
7987 if (!SWIG_IsOK(ecode2)) {
7988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7989 }
7990 arg2 = static_cast< double >(val2);
7991 }
7992 {
7993 PyThreadState* __tstate = wxPyBeginAllowThreads();
7994 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7995 wxPyEndAllowThreads(__tstate);
7996 if (PyErr_Occurred()) SWIG_fail;
7997 }
7998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7999 return resultobj;
8000 fail:
8001 return NULL;
8002 }
8003
8004
8005 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8006 PyObject *resultobj = 0;
8007 wxPoint2D *arg1 = 0 ;
8008 wxPoint2D *result = 0 ;
8009 wxPoint2D temp1 ;
8010 PyObject * obj0 = 0 ;
8011 char * kwnames[] = {
8012 (char *) "pt", NULL
8013 };
8014
8015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8016 {
8017 arg1 = &temp1;
8018 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8019 }
8020 {
8021 PyThreadState* __tstate = wxPyBeginAllowThreads();
8022 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8023 wxPyEndAllowThreads(__tstate);
8024 if (PyErr_Occurred()) SWIG_fail;
8025 }
8026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8027 return resultobj;
8028 fail:
8029 return NULL;
8030 }
8031
8032
8033 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8034 PyObject *resultobj = 0;
8035 wxPoint *arg1 = 0 ;
8036 wxPoint2D *result = 0 ;
8037 wxPoint temp1 ;
8038 PyObject * obj0 = 0 ;
8039 char * kwnames[] = {
8040 (char *) "pt", NULL
8041 };
8042
8043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8044 {
8045 arg1 = &temp1;
8046 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8047 }
8048 {
8049 PyThreadState* __tstate = wxPyBeginAllowThreads();
8050 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8051 wxPyEndAllowThreads(__tstate);
8052 if (PyErr_Occurred()) SWIG_fail;
8053 }
8054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8055 return resultobj;
8056 fail:
8057 return NULL;
8058 }
8059
8060
8061 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8062 PyObject *resultobj = 0;
8063 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8064 int *arg2 = (int *) 0 ;
8065 int *arg3 = (int *) 0 ;
8066 void *argp1 = 0 ;
8067 int res1 = 0 ;
8068 int temp2 ;
8069 int res2 = SWIG_TMPOBJ ;
8070 int temp3 ;
8071 int res3 = SWIG_TMPOBJ ;
8072 PyObject *swig_obj[1] ;
8073
8074 arg2 = &temp2;
8075 arg3 = &temp3;
8076 if (!args) SWIG_fail;
8077 swig_obj[0] = args;
8078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8079 if (!SWIG_IsOK(res1)) {
8080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8081 }
8082 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8083 {
8084 PyThreadState* __tstate = wxPyBeginAllowThreads();
8085 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8086 wxPyEndAllowThreads(__tstate);
8087 if (PyErr_Occurred()) SWIG_fail;
8088 }
8089 resultobj = SWIG_Py_Void();
8090 if (SWIG_IsTmpObj(res2)) {
8091 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8092 } else {
8093 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8094 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8095 }
8096 if (SWIG_IsTmpObj(res3)) {
8097 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8098 } else {
8099 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8100 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8101 }
8102 return resultobj;
8103 fail:
8104 return NULL;
8105 }
8106
8107
8108 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8109 PyObject *resultobj = 0;
8110 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8111 int *arg2 = (int *) 0 ;
8112 int *arg3 = (int *) 0 ;
8113 void *argp1 = 0 ;
8114 int res1 = 0 ;
8115 int temp2 ;
8116 int res2 = SWIG_TMPOBJ ;
8117 int temp3 ;
8118 int res3 = SWIG_TMPOBJ ;
8119 PyObject *swig_obj[1] ;
8120
8121 arg2 = &temp2;
8122 arg3 = &temp3;
8123 if (!args) SWIG_fail;
8124 swig_obj[0] = args;
8125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8126 if (!SWIG_IsOK(res1)) {
8127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8128 }
8129 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8130 {
8131 PyThreadState* __tstate = wxPyBeginAllowThreads();
8132 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8133 wxPyEndAllowThreads(__tstate);
8134 if (PyErr_Occurred()) SWIG_fail;
8135 }
8136 resultobj = SWIG_Py_Void();
8137 if (SWIG_IsTmpObj(res2)) {
8138 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8139 } else {
8140 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8141 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8142 }
8143 if (SWIG_IsTmpObj(res3)) {
8144 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8145 } else {
8146 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8147 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8148 }
8149 return resultobj;
8150 fail:
8151 return NULL;
8152 }
8153
8154
8155 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8156 PyObject *resultobj = 0;
8157 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8158 double result;
8159 void *argp1 = 0 ;
8160 int res1 = 0 ;
8161 PyObject *swig_obj[1] ;
8162
8163 if (!args) SWIG_fail;
8164 swig_obj[0] = args;
8165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8166 if (!SWIG_IsOK(res1)) {
8167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8168 }
8169 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8170 {
8171 PyThreadState* __tstate = wxPyBeginAllowThreads();
8172 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8173 wxPyEndAllowThreads(__tstate);
8174 if (PyErr_Occurred()) SWIG_fail;
8175 }
8176 resultobj = SWIG_From_double(static_cast< double >(result));
8177 return resultobj;
8178 fail:
8179 return NULL;
8180 }
8181
8182
8183 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8184 PyObject *resultobj = 0;
8185 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8186 double result;
8187 void *argp1 = 0 ;
8188 int res1 = 0 ;
8189 PyObject *swig_obj[1] ;
8190
8191 if (!args) SWIG_fail;
8192 swig_obj[0] = args;
8193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8194 if (!SWIG_IsOK(res1)) {
8195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8196 }
8197 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8198 {
8199 PyThreadState* __tstate = wxPyBeginAllowThreads();
8200 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8201 wxPyEndAllowThreads(__tstate);
8202 if (PyErr_Occurred()) SWIG_fail;
8203 }
8204 resultobj = SWIG_From_double(static_cast< double >(result));
8205 return resultobj;
8206 fail:
8207 return NULL;
8208 }
8209
8210
8211 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8212 PyObject *resultobj = 0;
8213 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8214 double arg2 ;
8215 void *argp1 = 0 ;
8216 int res1 = 0 ;
8217 double val2 ;
8218 int ecode2 = 0 ;
8219 PyObject * obj0 = 0 ;
8220 PyObject * obj1 = 0 ;
8221 char * kwnames[] = {
8222 (char *) "self",(char *) "length", NULL
8223 };
8224
8225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8227 if (!SWIG_IsOK(res1)) {
8228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8229 }
8230 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8231 ecode2 = SWIG_AsVal_double(obj1, &val2);
8232 if (!SWIG_IsOK(ecode2)) {
8233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8234 }
8235 arg2 = static_cast< double >(val2);
8236 {
8237 PyThreadState* __tstate = wxPyBeginAllowThreads();
8238 (arg1)->SetVectorLength(arg2);
8239 wxPyEndAllowThreads(__tstate);
8240 if (PyErr_Occurred()) SWIG_fail;
8241 }
8242 resultobj = SWIG_Py_Void();
8243 return resultobj;
8244 fail:
8245 return NULL;
8246 }
8247
8248
8249 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8250 PyObject *resultobj = 0;
8251 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8252 double arg2 ;
8253 void *argp1 = 0 ;
8254 int res1 = 0 ;
8255 double val2 ;
8256 int ecode2 = 0 ;
8257 PyObject * obj0 = 0 ;
8258 PyObject * obj1 = 0 ;
8259 char * kwnames[] = {
8260 (char *) "self",(char *) "degrees", NULL
8261 };
8262
8263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8265 if (!SWIG_IsOK(res1)) {
8266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8267 }
8268 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8269 ecode2 = SWIG_AsVal_double(obj1, &val2);
8270 if (!SWIG_IsOK(ecode2)) {
8271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8272 }
8273 arg2 = static_cast< double >(val2);
8274 {
8275 PyThreadState* __tstate = wxPyBeginAllowThreads();
8276 (arg1)->SetVectorAngle(arg2);
8277 wxPyEndAllowThreads(__tstate);
8278 if (PyErr_Occurred()) SWIG_fail;
8279 }
8280 resultobj = SWIG_Py_Void();
8281 return resultobj;
8282 fail:
8283 return NULL;
8284 }
8285
8286
8287 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8288 PyObject *resultobj = 0;
8289 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8290 wxPoint2D *arg2 = 0 ;
8291 double result;
8292 void *argp1 = 0 ;
8293 int res1 = 0 ;
8294 wxPoint2D temp2 ;
8295 PyObject * obj0 = 0 ;
8296 PyObject * obj1 = 0 ;
8297 char * kwnames[] = {
8298 (char *) "self",(char *) "pt", NULL
8299 };
8300
8301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8303 if (!SWIG_IsOK(res1)) {
8304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8305 }
8306 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8307 {
8308 arg2 = &temp2;
8309 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8310 }
8311 {
8312 PyThreadState* __tstate = wxPyBeginAllowThreads();
8313 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8314 wxPyEndAllowThreads(__tstate);
8315 if (PyErr_Occurred()) SWIG_fail;
8316 }
8317 resultobj = SWIG_From_double(static_cast< double >(result));
8318 return resultobj;
8319 fail:
8320 return NULL;
8321 }
8322
8323
8324 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8325 PyObject *resultobj = 0;
8326 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8327 wxPoint2D *arg2 = 0 ;
8328 double result;
8329 void *argp1 = 0 ;
8330 int res1 = 0 ;
8331 wxPoint2D temp2 ;
8332 PyObject * obj0 = 0 ;
8333 PyObject * obj1 = 0 ;
8334 char * kwnames[] = {
8335 (char *) "self",(char *) "pt", NULL
8336 };
8337
8338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8340 if (!SWIG_IsOK(res1)) {
8341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8342 }
8343 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8344 {
8345 arg2 = &temp2;
8346 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8347 }
8348 {
8349 PyThreadState* __tstate = wxPyBeginAllowThreads();
8350 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8351 wxPyEndAllowThreads(__tstate);
8352 if (PyErr_Occurred()) SWIG_fail;
8353 }
8354 resultobj = SWIG_From_double(static_cast< double >(result));
8355 return resultobj;
8356 fail:
8357 return NULL;
8358 }
8359
8360
8361 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8362 PyObject *resultobj = 0;
8363 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8364 wxPoint2D *arg2 = 0 ;
8365 double result;
8366 void *argp1 = 0 ;
8367 int res1 = 0 ;
8368 wxPoint2D temp2 ;
8369 PyObject * obj0 = 0 ;
8370 PyObject * obj1 = 0 ;
8371 char * kwnames[] = {
8372 (char *) "self",(char *) "vec", NULL
8373 };
8374
8375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8377 if (!SWIG_IsOK(res1)) {
8378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8379 }
8380 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8381 {
8382 arg2 = &temp2;
8383 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8384 }
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8388 wxPyEndAllowThreads(__tstate);
8389 if (PyErr_Occurred()) SWIG_fail;
8390 }
8391 resultobj = SWIG_From_double(static_cast< double >(result));
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8399 PyObject *resultobj = 0;
8400 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8401 wxPoint2D *arg2 = 0 ;
8402 double result;
8403 void *argp1 = 0 ;
8404 int res1 = 0 ;
8405 wxPoint2D temp2 ;
8406 PyObject * obj0 = 0 ;
8407 PyObject * obj1 = 0 ;
8408 char * kwnames[] = {
8409 (char *) "self",(char *) "vec", NULL
8410 };
8411
8412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8414 if (!SWIG_IsOK(res1)) {
8415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8416 }
8417 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8418 {
8419 arg2 = &temp2;
8420 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8421 }
8422 {
8423 PyThreadState* __tstate = wxPyBeginAllowThreads();
8424 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8425 wxPyEndAllowThreads(__tstate);
8426 if (PyErr_Occurred()) SWIG_fail;
8427 }
8428 resultobj = SWIG_From_double(static_cast< double >(result));
8429 return resultobj;
8430 fail:
8431 return NULL;
8432 }
8433
8434
8435 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8436 PyObject *resultobj = 0;
8437 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8438 wxPoint2D result;
8439 void *argp1 = 0 ;
8440 int res1 = 0 ;
8441 PyObject *swig_obj[1] ;
8442
8443 if (!args) SWIG_fail;
8444 swig_obj[0] = args;
8445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8446 if (!SWIG_IsOK(res1)) {
8447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8448 }
8449 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8450 {
8451 PyThreadState* __tstate = wxPyBeginAllowThreads();
8452 result = (arg1)->operator -();
8453 wxPyEndAllowThreads(__tstate);
8454 if (PyErr_Occurred()) SWIG_fail;
8455 }
8456 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8457 return resultobj;
8458 fail:
8459 return NULL;
8460 }
8461
8462
8463 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8464 PyObject *resultobj = 0;
8465 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8466 wxPoint2D *arg2 = 0 ;
8467 wxPoint2D *result = 0 ;
8468 void *argp1 = 0 ;
8469 int res1 = 0 ;
8470 wxPoint2D temp2 ;
8471 PyObject * obj0 = 0 ;
8472 PyObject * obj1 = 0 ;
8473 char * kwnames[] = {
8474 (char *) "self",(char *) "pt", NULL
8475 };
8476
8477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8479 if (!SWIG_IsOK(res1)) {
8480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8481 }
8482 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8483 {
8484 arg2 = &temp2;
8485 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8486 }
8487 {
8488 PyThreadState* __tstate = wxPyBeginAllowThreads();
8489 {
8490 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8491 result = (wxPoint2D *) &_result_ref;
8492 }
8493 wxPyEndAllowThreads(__tstate);
8494 if (PyErr_Occurred()) SWIG_fail;
8495 }
8496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8497 return resultobj;
8498 fail:
8499 return NULL;
8500 }
8501
8502
8503 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8504 PyObject *resultobj = 0;
8505 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8506 wxPoint2D *arg2 = 0 ;
8507 wxPoint2D *result = 0 ;
8508 void *argp1 = 0 ;
8509 int res1 = 0 ;
8510 wxPoint2D temp2 ;
8511 PyObject * obj0 = 0 ;
8512 PyObject * obj1 = 0 ;
8513 char * kwnames[] = {
8514 (char *) "self",(char *) "pt", NULL
8515 };
8516
8517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8519 if (!SWIG_IsOK(res1)) {
8520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8521 }
8522 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8523 {
8524 arg2 = &temp2;
8525 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8526 }
8527 {
8528 PyThreadState* __tstate = wxPyBeginAllowThreads();
8529 {
8530 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8531 result = (wxPoint2D *) &_result_ref;
8532 }
8533 wxPyEndAllowThreads(__tstate);
8534 if (PyErr_Occurred()) SWIG_fail;
8535 }
8536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8537 return resultobj;
8538 fail:
8539 return NULL;
8540 }
8541
8542
8543 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8544 PyObject *resultobj = 0;
8545 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8546 wxPoint2D *arg2 = 0 ;
8547 wxPoint2D *result = 0 ;
8548 void *argp1 = 0 ;
8549 int res1 = 0 ;
8550 wxPoint2D temp2 ;
8551 PyObject * obj0 = 0 ;
8552 PyObject * obj1 = 0 ;
8553 char * kwnames[] = {
8554 (char *) "self",(char *) "pt", NULL
8555 };
8556
8557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8559 if (!SWIG_IsOK(res1)) {
8560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8561 }
8562 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8563 {
8564 arg2 = &temp2;
8565 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8566 }
8567 {
8568 PyThreadState* __tstate = wxPyBeginAllowThreads();
8569 {
8570 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8571 result = (wxPoint2D *) &_result_ref;
8572 }
8573 wxPyEndAllowThreads(__tstate);
8574 if (PyErr_Occurred()) SWIG_fail;
8575 }
8576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8577 return resultobj;
8578 fail:
8579 return NULL;
8580 }
8581
8582
8583 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8584 PyObject *resultobj = 0;
8585 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8586 wxPoint2D *arg2 = 0 ;
8587 wxPoint2D *result = 0 ;
8588 void *argp1 = 0 ;
8589 int res1 = 0 ;
8590 wxPoint2D temp2 ;
8591 PyObject * obj0 = 0 ;
8592 PyObject * obj1 = 0 ;
8593 char * kwnames[] = {
8594 (char *) "self",(char *) "pt", NULL
8595 };
8596
8597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8599 if (!SWIG_IsOK(res1)) {
8600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8601 }
8602 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8603 {
8604 arg2 = &temp2;
8605 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8606 }
8607 {
8608 PyThreadState* __tstate = wxPyBeginAllowThreads();
8609 {
8610 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8611 result = (wxPoint2D *) &_result_ref;
8612 }
8613 wxPyEndAllowThreads(__tstate);
8614 if (PyErr_Occurred()) SWIG_fail;
8615 }
8616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8617 return resultobj;
8618 fail:
8619 return NULL;
8620 }
8621
8622
8623 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8624 PyObject *resultobj = 0;
8625 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8626 PyObject *arg2 = (PyObject *) 0 ;
8627 bool result;
8628 void *argp1 = 0 ;
8629 int res1 = 0 ;
8630 PyObject * obj0 = 0 ;
8631 PyObject * obj1 = 0 ;
8632 char * kwnames[] = {
8633 (char *) "self",(char *) "other", NULL
8634 };
8635
8636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8638 if (!SWIG_IsOK(res1)) {
8639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8640 }
8641 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8642 arg2 = obj1;
8643 {
8644 result = (bool)wxPoint2D___eq__(arg1,arg2);
8645 if (PyErr_Occurred()) SWIG_fail;
8646 }
8647 {
8648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8649 }
8650 return resultobj;
8651 fail:
8652 return NULL;
8653 }
8654
8655
8656 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8657 PyObject *resultobj = 0;
8658 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8659 PyObject *arg2 = (PyObject *) 0 ;
8660 bool result;
8661 void *argp1 = 0 ;
8662 int res1 = 0 ;
8663 PyObject * obj0 = 0 ;
8664 PyObject * obj1 = 0 ;
8665 char * kwnames[] = {
8666 (char *) "self",(char *) "other", NULL
8667 };
8668
8669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8671 if (!SWIG_IsOK(res1)) {
8672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8673 }
8674 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8675 arg2 = obj1;
8676 {
8677 result = (bool)wxPoint2D___ne__(arg1,arg2);
8678 if (PyErr_Occurred()) SWIG_fail;
8679 }
8680 {
8681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8682 }
8683 return resultobj;
8684 fail:
8685 return NULL;
8686 }
8687
8688
8689 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8690 PyObject *resultobj = 0;
8691 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8692 double arg2 ;
8693 void *argp1 = 0 ;
8694 int res1 = 0 ;
8695 double val2 ;
8696 int ecode2 = 0 ;
8697 PyObject *swig_obj[2] ;
8698
8699 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8701 if (!SWIG_IsOK(res1)) {
8702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8703 }
8704 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8705 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8706 if (!SWIG_IsOK(ecode2)) {
8707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8708 }
8709 arg2 = static_cast< double >(val2);
8710 if (arg1) (arg1)->m_x = arg2;
8711
8712 resultobj = SWIG_Py_Void();
8713 return resultobj;
8714 fail:
8715 return NULL;
8716 }
8717
8718
8719 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8720 PyObject *resultobj = 0;
8721 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8722 double result;
8723 void *argp1 = 0 ;
8724 int res1 = 0 ;
8725 PyObject *swig_obj[1] ;
8726
8727 if (!args) SWIG_fail;
8728 swig_obj[0] = args;
8729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8730 if (!SWIG_IsOK(res1)) {
8731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8732 }
8733 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8734 result = (double) ((arg1)->m_x);
8735 resultobj = SWIG_From_double(static_cast< double >(result));
8736 return resultobj;
8737 fail:
8738 return NULL;
8739 }
8740
8741
8742 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8743 PyObject *resultobj = 0;
8744 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8745 double arg2 ;
8746 void *argp1 = 0 ;
8747 int res1 = 0 ;
8748 double val2 ;
8749 int ecode2 = 0 ;
8750 PyObject *swig_obj[2] ;
8751
8752 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8754 if (!SWIG_IsOK(res1)) {
8755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8756 }
8757 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8758 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8759 if (!SWIG_IsOK(ecode2)) {
8760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8761 }
8762 arg2 = static_cast< double >(val2);
8763 if (arg1) (arg1)->m_y = arg2;
8764
8765 resultobj = SWIG_Py_Void();
8766 return resultobj;
8767 fail:
8768 return NULL;
8769 }
8770
8771
8772 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8773 PyObject *resultobj = 0;
8774 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8775 double result;
8776 void *argp1 = 0 ;
8777 int res1 = 0 ;
8778 PyObject *swig_obj[1] ;
8779
8780 if (!args) SWIG_fail;
8781 swig_obj[0] = args;
8782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8783 if (!SWIG_IsOK(res1)) {
8784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8785 }
8786 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8787 result = (double) ((arg1)->m_y);
8788 resultobj = SWIG_From_double(static_cast< double >(result));
8789 return resultobj;
8790 fail:
8791 return NULL;
8792 }
8793
8794
8795 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8796 PyObject *resultobj = 0;
8797 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8798 double arg2 = (double) 0 ;
8799 double arg3 = (double) 0 ;
8800 void *argp1 = 0 ;
8801 int res1 = 0 ;
8802 double val2 ;
8803 int ecode2 = 0 ;
8804 double val3 ;
8805 int ecode3 = 0 ;
8806 PyObject * obj0 = 0 ;
8807 PyObject * obj1 = 0 ;
8808 PyObject * obj2 = 0 ;
8809 char * kwnames[] = {
8810 (char *) "self",(char *) "x",(char *) "y", NULL
8811 };
8812
8813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8815 if (!SWIG_IsOK(res1)) {
8816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8817 }
8818 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8819 if (obj1) {
8820 ecode2 = SWIG_AsVal_double(obj1, &val2);
8821 if (!SWIG_IsOK(ecode2)) {
8822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8823 }
8824 arg2 = static_cast< double >(val2);
8825 }
8826 if (obj2) {
8827 ecode3 = SWIG_AsVal_double(obj2, &val3);
8828 if (!SWIG_IsOK(ecode3)) {
8829 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8830 }
8831 arg3 = static_cast< double >(val3);
8832 }
8833 {
8834 PyThreadState* __tstate = wxPyBeginAllowThreads();
8835 wxPoint2D_Set(arg1,arg2,arg3);
8836 wxPyEndAllowThreads(__tstate);
8837 if (PyErr_Occurred()) SWIG_fail;
8838 }
8839 resultobj = SWIG_Py_Void();
8840 return resultobj;
8841 fail:
8842 return NULL;
8843 }
8844
8845
8846 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8847 PyObject *resultobj = 0;
8848 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8849 PyObject *result = 0 ;
8850 void *argp1 = 0 ;
8851 int res1 = 0 ;
8852 PyObject *swig_obj[1] ;
8853
8854 if (!args) SWIG_fail;
8855 swig_obj[0] = args;
8856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8857 if (!SWIG_IsOK(res1)) {
8858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8859 }
8860 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8861 {
8862 PyThreadState* __tstate = wxPyBeginAllowThreads();
8863 result = (PyObject *)wxPoint2D_Get(arg1);
8864 wxPyEndAllowThreads(__tstate);
8865 if (PyErr_Occurred()) SWIG_fail;
8866 }
8867 resultobj = result;
8868 return resultobj;
8869 fail:
8870 return NULL;
8871 }
8872
8873
8874 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8875 PyObject *obj;
8876 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8877 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8878 return SWIG_Py_Void();
8879 }
8880
8881 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8882 return SWIG_Python_InitShadowInstance(args);
8883 }
8884
8885 SWIGINTERN int DefaultPosition_set(PyObject *) {
8886 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8887 return 1;
8888 }
8889
8890
8891 SWIGINTERN PyObject *DefaultPosition_get(void) {
8892 PyObject *pyobj = 0;
8893
8894 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8895 return pyobj;
8896 }
8897
8898
8899 SWIGINTERN int DefaultSize_set(PyObject *) {
8900 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8901 return 1;
8902 }
8903
8904
8905 SWIGINTERN PyObject *DefaultSize_get(void) {
8906 PyObject *pyobj = 0;
8907
8908 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8909 return pyobj;
8910 }
8911
8912
8913 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8914 PyObject *resultobj = 0;
8915 PyObject *arg1 = (PyObject *) 0 ;
8916 wxPyInputStream *result = 0 ;
8917 PyObject * obj0 = 0 ;
8918 char * kwnames[] = {
8919 (char *) "p", NULL
8920 };
8921
8922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8923 arg1 = obj0;
8924 {
8925 PyThreadState* __tstate = wxPyBeginAllowThreads();
8926 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8927 wxPyEndAllowThreads(__tstate);
8928 if (PyErr_Occurred()) SWIG_fail;
8929 }
8930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8931 return resultobj;
8932 fail:
8933 return NULL;
8934 }
8935
8936
8937 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8938 PyObject *resultobj = 0;
8939 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8940 void *argp1 = 0 ;
8941 int res1 = 0 ;
8942 PyObject *swig_obj[1] ;
8943
8944 if (!args) SWIG_fail;
8945 swig_obj[0] = args;
8946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8947 if (!SWIG_IsOK(res1)) {
8948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8949 }
8950 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8951 {
8952 PyThreadState* __tstate = wxPyBeginAllowThreads();
8953 delete arg1;
8954
8955 wxPyEndAllowThreads(__tstate);
8956 if (PyErr_Occurred()) SWIG_fail;
8957 }
8958 resultobj = SWIG_Py_Void();
8959 return resultobj;
8960 fail:
8961 return NULL;
8962 }
8963
8964
8965 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8966 PyObject *resultobj = 0;
8967 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8968 void *argp1 = 0 ;
8969 int res1 = 0 ;
8970 PyObject *swig_obj[1] ;
8971
8972 if (!args) SWIG_fail;
8973 swig_obj[0] = args;
8974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8975 if (!SWIG_IsOK(res1)) {
8976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8977 }
8978 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8979 {
8980 PyThreadState* __tstate = wxPyBeginAllowThreads();
8981 (arg1)->close();
8982 wxPyEndAllowThreads(__tstate);
8983 if (PyErr_Occurred()) SWIG_fail;
8984 }
8985 resultobj = SWIG_Py_Void();
8986 return resultobj;
8987 fail:
8988 return NULL;
8989 }
8990
8991
8992 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8993 PyObject *resultobj = 0;
8994 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8995 void *argp1 = 0 ;
8996 int res1 = 0 ;
8997 PyObject *swig_obj[1] ;
8998
8999 if (!args) SWIG_fail;
9000 swig_obj[0] = args;
9001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9002 if (!SWIG_IsOK(res1)) {
9003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9004 }
9005 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9006 {
9007 PyThreadState* __tstate = wxPyBeginAllowThreads();
9008 (arg1)->flush();
9009 wxPyEndAllowThreads(__tstate);
9010 if (PyErr_Occurred()) SWIG_fail;
9011 }
9012 resultobj = SWIG_Py_Void();
9013 return resultobj;
9014 fail:
9015 return NULL;
9016 }
9017
9018
9019 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9020 PyObject *resultobj = 0;
9021 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9022 bool result;
9023 void *argp1 = 0 ;
9024 int res1 = 0 ;
9025 PyObject *swig_obj[1] ;
9026
9027 if (!args) SWIG_fail;
9028 swig_obj[0] = args;
9029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9030 if (!SWIG_IsOK(res1)) {
9031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9032 }
9033 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9034 {
9035 PyThreadState* __tstate = wxPyBeginAllowThreads();
9036 result = (bool)(arg1)->eof();
9037 wxPyEndAllowThreads(__tstate);
9038 if (PyErr_Occurred()) SWIG_fail;
9039 }
9040 {
9041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9042 }
9043 return resultobj;
9044 fail:
9045 return NULL;
9046 }
9047
9048
9049 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9050 PyObject *resultobj = 0;
9051 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9052 int arg2 = (int) -1 ;
9053 PyObject *result = 0 ;
9054 void *argp1 = 0 ;
9055 int res1 = 0 ;
9056 int val2 ;
9057 int ecode2 = 0 ;
9058 PyObject * obj0 = 0 ;
9059 PyObject * obj1 = 0 ;
9060 char * kwnames[] = {
9061 (char *) "self",(char *) "size", NULL
9062 };
9063
9064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9066 if (!SWIG_IsOK(res1)) {
9067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9068 }
9069 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9070 if (obj1) {
9071 ecode2 = SWIG_AsVal_int(obj1, &val2);
9072 if (!SWIG_IsOK(ecode2)) {
9073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9074 }
9075 arg2 = static_cast< int >(val2);
9076 }
9077 {
9078 PyThreadState* __tstate = wxPyBeginAllowThreads();
9079 result = (PyObject *)(arg1)->read(arg2);
9080 wxPyEndAllowThreads(__tstate);
9081 if (PyErr_Occurred()) SWIG_fail;
9082 }
9083 resultobj = result;
9084 return resultobj;
9085 fail:
9086 return NULL;
9087 }
9088
9089
9090 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9091 PyObject *resultobj = 0;
9092 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9093 int arg2 = (int) -1 ;
9094 PyObject *result = 0 ;
9095 void *argp1 = 0 ;
9096 int res1 = 0 ;
9097 int val2 ;
9098 int ecode2 = 0 ;
9099 PyObject * obj0 = 0 ;
9100 PyObject * obj1 = 0 ;
9101 char * kwnames[] = {
9102 (char *) "self",(char *) "size", NULL
9103 };
9104
9105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9107 if (!SWIG_IsOK(res1)) {
9108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9109 }
9110 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9111 if (obj1) {
9112 ecode2 = SWIG_AsVal_int(obj1, &val2);
9113 if (!SWIG_IsOK(ecode2)) {
9114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9115 }
9116 arg2 = static_cast< int >(val2);
9117 }
9118 {
9119 PyThreadState* __tstate = wxPyBeginAllowThreads();
9120 result = (PyObject *)(arg1)->readline(arg2);
9121 wxPyEndAllowThreads(__tstate);
9122 if (PyErr_Occurred()) SWIG_fail;
9123 }
9124 resultobj = result;
9125 return resultobj;
9126 fail:
9127 return NULL;
9128 }
9129
9130
9131 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9132 PyObject *resultobj = 0;
9133 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9134 int arg2 = (int) -1 ;
9135 PyObject *result = 0 ;
9136 void *argp1 = 0 ;
9137 int res1 = 0 ;
9138 int val2 ;
9139 int ecode2 = 0 ;
9140 PyObject * obj0 = 0 ;
9141 PyObject * obj1 = 0 ;
9142 char * kwnames[] = {
9143 (char *) "self",(char *) "sizehint", NULL
9144 };
9145
9146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9148 if (!SWIG_IsOK(res1)) {
9149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9150 }
9151 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9152 if (obj1) {
9153 ecode2 = SWIG_AsVal_int(obj1, &val2);
9154 if (!SWIG_IsOK(ecode2)) {
9155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9156 }
9157 arg2 = static_cast< int >(val2);
9158 }
9159 {
9160 PyThreadState* __tstate = wxPyBeginAllowThreads();
9161 result = (PyObject *)(arg1)->readlines(arg2);
9162 wxPyEndAllowThreads(__tstate);
9163 if (PyErr_Occurred()) SWIG_fail;
9164 }
9165 resultobj = result;
9166 return resultobj;
9167 fail:
9168 return NULL;
9169 }
9170
9171
9172 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9173 PyObject *resultobj = 0;
9174 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9175 int arg2 ;
9176 int arg3 = (int) 0 ;
9177 void *argp1 = 0 ;
9178 int res1 = 0 ;
9179 int val2 ;
9180 int ecode2 = 0 ;
9181 int val3 ;
9182 int ecode3 = 0 ;
9183 PyObject * obj0 = 0 ;
9184 PyObject * obj1 = 0 ;
9185 PyObject * obj2 = 0 ;
9186 char * kwnames[] = {
9187 (char *) "self",(char *) "offset",(char *) "whence", NULL
9188 };
9189
9190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9192 if (!SWIG_IsOK(res1)) {
9193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9194 }
9195 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9196 ecode2 = SWIG_AsVal_int(obj1, &val2);
9197 if (!SWIG_IsOK(ecode2)) {
9198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9199 }
9200 arg2 = static_cast< int >(val2);
9201 if (obj2) {
9202 ecode3 = SWIG_AsVal_int(obj2, &val3);
9203 if (!SWIG_IsOK(ecode3)) {
9204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9205 }
9206 arg3 = static_cast< int >(val3);
9207 }
9208 {
9209 PyThreadState* __tstate = wxPyBeginAllowThreads();
9210 (arg1)->seek(arg2,arg3);
9211 wxPyEndAllowThreads(__tstate);
9212 if (PyErr_Occurred()) SWIG_fail;
9213 }
9214 resultobj = SWIG_Py_Void();
9215 return resultobj;
9216 fail:
9217 return NULL;
9218 }
9219
9220
9221 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9222 PyObject *resultobj = 0;
9223 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9224 int result;
9225 void *argp1 = 0 ;
9226 int res1 = 0 ;
9227 PyObject *swig_obj[1] ;
9228
9229 if (!args) SWIG_fail;
9230 swig_obj[0] = args;
9231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9232 if (!SWIG_IsOK(res1)) {
9233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9234 }
9235 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9236 {
9237 PyThreadState* __tstate = wxPyBeginAllowThreads();
9238 result = (int)(arg1)->tell();
9239 wxPyEndAllowThreads(__tstate);
9240 if (PyErr_Occurred()) SWIG_fail;
9241 }
9242 resultobj = SWIG_From_int(static_cast< int >(result));
9243 return resultobj;
9244 fail:
9245 return NULL;
9246 }
9247
9248
9249 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9250 PyObject *resultobj = 0;
9251 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9252 char result;
9253 void *argp1 = 0 ;
9254 int res1 = 0 ;
9255 PyObject *swig_obj[1] ;
9256
9257 if (!args) SWIG_fail;
9258 swig_obj[0] = args;
9259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9260 if (!SWIG_IsOK(res1)) {
9261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9262 }
9263 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9264 {
9265 PyThreadState* __tstate = wxPyBeginAllowThreads();
9266 result = (char)(arg1)->Peek();
9267 wxPyEndAllowThreads(__tstate);
9268 if (PyErr_Occurred()) SWIG_fail;
9269 }
9270 resultobj = SWIG_From_char(static_cast< char >(result));
9271 return resultobj;
9272 fail:
9273 return NULL;
9274 }
9275
9276
9277 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9278 PyObject *resultobj = 0;
9279 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9280 char result;
9281 void *argp1 = 0 ;
9282 int res1 = 0 ;
9283 PyObject *swig_obj[1] ;
9284
9285 if (!args) SWIG_fail;
9286 swig_obj[0] = args;
9287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9288 if (!SWIG_IsOK(res1)) {
9289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9290 }
9291 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9292 {
9293 PyThreadState* __tstate = wxPyBeginAllowThreads();
9294 result = (char)(arg1)->GetC();
9295 wxPyEndAllowThreads(__tstate);
9296 if (PyErr_Occurred()) SWIG_fail;
9297 }
9298 resultobj = SWIG_From_char(static_cast< char >(result));
9299 return resultobj;
9300 fail:
9301 return NULL;
9302 }
9303
9304
9305 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9306 PyObject *resultobj = 0;
9307 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9308 size_t result;
9309 void *argp1 = 0 ;
9310 int res1 = 0 ;
9311 PyObject *swig_obj[1] ;
9312
9313 if (!args) SWIG_fail;
9314 swig_obj[0] = args;
9315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9316 if (!SWIG_IsOK(res1)) {
9317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9318 }
9319 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9320 {
9321 PyThreadState* __tstate = wxPyBeginAllowThreads();
9322 result = (size_t)(arg1)->LastRead();
9323 wxPyEndAllowThreads(__tstate);
9324 if (PyErr_Occurred()) SWIG_fail;
9325 }
9326 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9327 return resultobj;
9328 fail:
9329 return NULL;
9330 }
9331
9332
9333 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9334 PyObject *resultobj = 0;
9335 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9336 bool result;
9337 void *argp1 = 0 ;
9338 int res1 = 0 ;
9339 PyObject *swig_obj[1] ;
9340
9341 if (!args) SWIG_fail;
9342 swig_obj[0] = args;
9343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9344 if (!SWIG_IsOK(res1)) {
9345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9346 }
9347 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9348 {
9349 PyThreadState* __tstate = wxPyBeginAllowThreads();
9350 result = (bool)(arg1)->CanRead();
9351 wxPyEndAllowThreads(__tstate);
9352 if (PyErr_Occurred()) SWIG_fail;
9353 }
9354 {
9355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9356 }
9357 return resultobj;
9358 fail:
9359 return NULL;
9360 }
9361
9362
9363 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9364 PyObject *resultobj = 0;
9365 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9366 bool result;
9367 void *argp1 = 0 ;
9368 int res1 = 0 ;
9369 PyObject *swig_obj[1] ;
9370
9371 if (!args) SWIG_fail;
9372 swig_obj[0] = args;
9373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9374 if (!SWIG_IsOK(res1)) {
9375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9376 }
9377 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9378 {
9379 PyThreadState* __tstate = wxPyBeginAllowThreads();
9380 result = (bool)(arg1)->Eof();
9381 wxPyEndAllowThreads(__tstate);
9382 if (PyErr_Occurred()) SWIG_fail;
9383 }
9384 {
9385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9386 }
9387 return resultobj;
9388 fail:
9389 return NULL;
9390 }
9391
9392
9393 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9394 PyObject *resultobj = 0;
9395 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9396 char arg2 ;
9397 bool result;
9398 void *argp1 = 0 ;
9399 int res1 = 0 ;
9400 char val2 ;
9401 int ecode2 = 0 ;
9402 PyObject * obj0 = 0 ;
9403 PyObject * obj1 = 0 ;
9404 char * kwnames[] = {
9405 (char *) "self",(char *) "c", NULL
9406 };
9407
9408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9410 if (!SWIG_IsOK(res1)) {
9411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9412 }
9413 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9414 ecode2 = SWIG_AsVal_char(obj1, &val2);
9415 if (!SWIG_IsOK(ecode2)) {
9416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9417 }
9418 arg2 = static_cast< char >(val2);
9419 {
9420 PyThreadState* __tstate = wxPyBeginAllowThreads();
9421 result = (bool)(arg1)->Ungetch(arg2);
9422 wxPyEndAllowThreads(__tstate);
9423 if (PyErr_Occurred()) SWIG_fail;
9424 }
9425 {
9426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9427 }
9428 return resultobj;
9429 fail:
9430 return NULL;
9431 }
9432
9433
9434 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9435 PyObject *resultobj = 0;
9436 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9437 long arg2 ;
9438 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9439 long result;
9440 void *argp1 = 0 ;
9441 int res1 = 0 ;
9442 long val2 ;
9443 int ecode2 = 0 ;
9444 int val3 ;
9445 int ecode3 = 0 ;
9446 PyObject * obj0 = 0 ;
9447 PyObject * obj1 = 0 ;
9448 PyObject * obj2 = 0 ;
9449 char * kwnames[] = {
9450 (char *) "self",(char *) "pos",(char *) "mode", NULL
9451 };
9452
9453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9455 if (!SWIG_IsOK(res1)) {
9456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9457 }
9458 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9459 ecode2 = SWIG_AsVal_long(obj1, &val2);
9460 if (!SWIG_IsOK(ecode2)) {
9461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9462 }
9463 arg2 = static_cast< long >(val2);
9464 if (obj2) {
9465 ecode3 = SWIG_AsVal_int(obj2, &val3);
9466 if (!SWIG_IsOK(ecode3)) {
9467 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9468 }
9469 arg3 = static_cast< wxSeekMode >(val3);
9470 }
9471 {
9472 PyThreadState* __tstate = wxPyBeginAllowThreads();
9473 result = (long)(arg1)->SeekI(arg2,arg3);
9474 wxPyEndAllowThreads(__tstate);
9475 if (PyErr_Occurred()) SWIG_fail;
9476 }
9477 resultobj = SWIG_From_long(static_cast< long >(result));
9478 return resultobj;
9479 fail:
9480 return NULL;
9481 }
9482
9483
9484 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9485 PyObject *resultobj = 0;
9486 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9487 long result;
9488 void *argp1 = 0 ;
9489 int res1 = 0 ;
9490 PyObject *swig_obj[1] ;
9491
9492 if (!args) SWIG_fail;
9493 swig_obj[0] = args;
9494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9495 if (!SWIG_IsOK(res1)) {
9496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9497 }
9498 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9499 {
9500 PyThreadState* __tstate = wxPyBeginAllowThreads();
9501 result = (long)(arg1)->TellI();
9502 wxPyEndAllowThreads(__tstate);
9503 if (PyErr_Occurred()) SWIG_fail;
9504 }
9505 resultobj = SWIG_From_long(static_cast< long >(result));
9506 return resultobj;
9507 fail:
9508 return NULL;
9509 }
9510
9511
9512 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9513 PyObject *obj;
9514 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9515 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9516 return SWIG_Py_Void();
9517 }
9518
9519 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9520 return SWIG_Python_InitShadowInstance(args);
9521 }
9522
9523 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9524 PyObject *resultobj = 0;
9525 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9526 PyObject *arg2 = (PyObject *) 0 ;
9527 void *argp1 = 0 ;
9528 int res1 = 0 ;
9529 PyObject * obj0 = 0 ;
9530 PyObject * obj1 = 0 ;
9531 char * kwnames[] = {
9532 (char *) "self",(char *) "obj", NULL
9533 };
9534
9535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9537 if (!SWIG_IsOK(res1)) {
9538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9539 }
9540 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9541 arg2 = obj1;
9542 {
9543 PyThreadState* __tstate = wxPyBeginAllowThreads();
9544 wxOutputStream_write(arg1,arg2);
9545 wxPyEndAllowThreads(__tstate);
9546 if (PyErr_Occurred()) SWIG_fail;
9547 }
9548 resultobj = SWIG_Py_Void();
9549 return resultobj;
9550 fail:
9551 return NULL;
9552 }
9553
9554
9555 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9556 PyObject *resultobj = 0;
9557 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9558 size_t result;
9559 void *argp1 = 0 ;
9560 int res1 = 0 ;
9561 PyObject *swig_obj[1] ;
9562
9563 if (!args) SWIG_fail;
9564 swig_obj[0] = args;
9565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9566 if (!SWIG_IsOK(res1)) {
9567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9568 }
9569 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9570 {
9571 PyThreadState* __tstate = wxPyBeginAllowThreads();
9572 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9573 wxPyEndAllowThreads(__tstate);
9574 if (PyErr_Occurred()) SWIG_fail;
9575 }
9576 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9577 return resultobj;
9578 fail:
9579 return NULL;
9580 }
9581
9582
9583 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9584 PyObject *obj;
9585 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9586 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9587 return SWIG_Py_Void();
9588 }
9589
9590 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9591 PyObject *resultobj = 0;
9592 wxInputStream *arg1 = (wxInputStream *) 0 ;
9593 wxString *arg2 = 0 ;
9594 wxString *arg3 = 0 ;
9595 wxString *arg4 = 0 ;
9596 wxDateTime arg5 ;
9597 wxFSFile *result = 0 ;
9598 wxPyInputStream *temp1 ;
9599 bool temp2 = false ;
9600 bool temp3 = false ;
9601 bool temp4 = false ;
9602 void *argp5 ;
9603 int res5 = 0 ;
9604 PyObject * obj0 = 0 ;
9605 PyObject * obj1 = 0 ;
9606 PyObject * obj2 = 0 ;
9607 PyObject * obj3 = 0 ;
9608 PyObject * obj4 = 0 ;
9609 char * kwnames[] = {
9610 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9611 };
9612
9613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9614 {
9615 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9616 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9617 } else {
9618 PyErr_Clear(); // clear the failure of the wxPyConvert above
9619 arg1 = wxPyCBInputStream_create(obj0, true);
9620 if (arg1 == NULL) {
9621 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9622 SWIG_fail;
9623 }
9624 }
9625 }
9626 {
9627 arg2 = wxString_in_helper(obj1);
9628 if (arg2 == NULL) SWIG_fail;
9629 temp2 = true;
9630 }
9631 {
9632 arg3 = wxString_in_helper(obj2);
9633 if (arg3 == NULL) SWIG_fail;
9634 temp3 = true;
9635 }
9636 {
9637 arg4 = wxString_in_helper(obj3);
9638 if (arg4 == NULL) SWIG_fail;
9639 temp4 = true;
9640 }
9641 {
9642 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9643 if (!SWIG_IsOK(res5)) {
9644 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9645 }
9646 if (!argp5) {
9647 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9648 } else {
9649 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9650 arg5 = *temp;
9651 if (SWIG_IsNewObj(res5)) delete temp;
9652 }
9653 }
9654 {
9655 PyThreadState* __tstate = wxPyBeginAllowThreads();
9656 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9657 wxPyEndAllowThreads(__tstate);
9658 if (PyErr_Occurred()) SWIG_fail;
9659 }
9660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9661 {
9662 if (temp2)
9663 delete arg2;
9664 }
9665 {
9666 if (temp3)
9667 delete arg3;
9668 }
9669 {
9670 if (temp4)
9671 delete arg4;
9672 }
9673 return resultobj;
9674 fail:
9675 {
9676 if (temp2)
9677 delete arg2;
9678 }
9679 {
9680 if (temp3)
9681 delete arg3;
9682 }
9683 {
9684 if (temp4)
9685 delete arg4;
9686 }
9687 return NULL;
9688 }
9689
9690
9691 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9692 PyObject *resultobj = 0;
9693 wxFSFile *arg1 = (wxFSFile *) 0 ;
9694 void *argp1 = 0 ;
9695 int res1 = 0 ;
9696 PyObject *swig_obj[1] ;
9697
9698 if (!args) SWIG_fail;
9699 swig_obj[0] = args;
9700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9701 if (!SWIG_IsOK(res1)) {
9702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9703 }
9704 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9705 {
9706 PyThreadState* __tstate = wxPyBeginAllowThreads();
9707 delete arg1;
9708
9709 wxPyEndAllowThreads(__tstate);
9710 if (PyErr_Occurred()) SWIG_fail;
9711 }
9712 resultobj = SWIG_Py_Void();
9713 return resultobj;
9714 fail:
9715 return NULL;
9716 }
9717
9718
9719 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9720 PyObject *resultobj = 0;
9721 wxFSFile *arg1 = (wxFSFile *) 0 ;
9722 wxInputStream *result = 0 ;
9723 void *argp1 = 0 ;
9724 int res1 = 0 ;
9725 PyObject *swig_obj[1] ;
9726
9727 if (!args) SWIG_fail;
9728 swig_obj[0] = args;
9729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9730 if (!SWIG_IsOK(res1)) {
9731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9732 }
9733 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9734 {
9735 PyThreadState* __tstate = wxPyBeginAllowThreads();
9736 result = (wxInputStream *)(arg1)->GetStream();
9737 wxPyEndAllowThreads(__tstate);
9738 if (PyErr_Occurred()) SWIG_fail;
9739 }
9740 {
9741 wxPyInputStream * _ptr = NULL;
9742
9743 if (result) {
9744 _ptr = new wxPyInputStream(result);
9745 }
9746 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9747 }
9748 return resultobj;
9749 fail:
9750 return NULL;
9751 }
9752
9753
9754 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9755 PyObject *resultobj = 0;
9756 wxFSFile *arg1 = (wxFSFile *) 0 ;
9757 wxString *result = 0 ;
9758 void *argp1 = 0 ;
9759 int res1 = 0 ;
9760 PyObject *swig_obj[1] ;
9761
9762 if (!args) SWIG_fail;
9763 swig_obj[0] = args;
9764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9765 if (!SWIG_IsOK(res1)) {
9766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9767 }
9768 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9769 {
9770 PyThreadState* __tstate = wxPyBeginAllowThreads();
9771 {
9772 wxString const &_result_ref = (arg1)->GetMimeType();
9773 result = (wxString *) &_result_ref;
9774 }
9775 wxPyEndAllowThreads(__tstate);
9776 if (PyErr_Occurred()) SWIG_fail;
9777 }
9778 {
9779 #if wxUSE_UNICODE
9780 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9781 #else
9782 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9783 #endif
9784 }
9785 return resultobj;
9786 fail:
9787 return NULL;
9788 }
9789
9790
9791 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9792 PyObject *resultobj = 0;
9793 wxFSFile *arg1 = (wxFSFile *) 0 ;
9794 wxString *result = 0 ;
9795 void *argp1 = 0 ;
9796 int res1 = 0 ;
9797 PyObject *swig_obj[1] ;
9798
9799 if (!args) SWIG_fail;
9800 swig_obj[0] = args;
9801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9802 if (!SWIG_IsOK(res1)) {
9803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9804 }
9805 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9806 {
9807 PyThreadState* __tstate = wxPyBeginAllowThreads();
9808 {
9809 wxString const &_result_ref = (arg1)->GetLocation();
9810 result = (wxString *) &_result_ref;
9811 }
9812 wxPyEndAllowThreads(__tstate);
9813 if (PyErr_Occurred()) SWIG_fail;
9814 }
9815 {
9816 #if wxUSE_UNICODE
9817 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9818 #else
9819 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9820 #endif
9821 }
9822 return resultobj;
9823 fail:
9824 return NULL;
9825 }
9826
9827
9828 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9829 PyObject *resultobj = 0;
9830 wxFSFile *arg1 = (wxFSFile *) 0 ;
9831 wxString *result = 0 ;
9832 void *argp1 = 0 ;
9833 int res1 = 0 ;
9834 PyObject *swig_obj[1] ;
9835
9836 if (!args) SWIG_fail;
9837 swig_obj[0] = args;
9838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9839 if (!SWIG_IsOK(res1)) {
9840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9841 }
9842 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9843 {
9844 PyThreadState* __tstate = wxPyBeginAllowThreads();
9845 {
9846 wxString const &_result_ref = (arg1)->GetAnchor();
9847 result = (wxString *) &_result_ref;
9848 }
9849 wxPyEndAllowThreads(__tstate);
9850 if (PyErr_Occurred()) SWIG_fail;
9851 }
9852 {
9853 #if wxUSE_UNICODE
9854 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9855 #else
9856 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9857 #endif
9858 }
9859 return resultobj;
9860 fail:
9861 return NULL;
9862 }
9863
9864
9865 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9866 PyObject *resultobj = 0;
9867 wxFSFile *arg1 = (wxFSFile *) 0 ;
9868 wxDateTime result;
9869 void *argp1 = 0 ;
9870 int res1 = 0 ;
9871 PyObject *swig_obj[1] ;
9872
9873 if (!args) SWIG_fail;
9874 swig_obj[0] = args;
9875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9876 if (!SWIG_IsOK(res1)) {
9877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9878 }
9879 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9880 {
9881 PyThreadState* __tstate = wxPyBeginAllowThreads();
9882 result = (arg1)->GetModificationTime();
9883 wxPyEndAllowThreads(__tstate);
9884 if (PyErr_Occurred()) SWIG_fail;
9885 }
9886 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9887 return resultobj;
9888 fail:
9889 return NULL;
9890 }
9891
9892
9893 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9894 PyObject *obj;
9895 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9896 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9897 return SWIG_Py_Void();
9898 }
9899
9900 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9901 return SWIG_Python_InitShadowInstance(args);
9902 }
9903
9904 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9905 PyObject *resultobj = 0;
9906 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9907 void *argp1 = 0 ;
9908 int res1 = 0 ;
9909 PyObject *swig_obj[1] ;
9910
9911 if (!args) SWIG_fail;
9912 swig_obj[0] = args;
9913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9914 if (!SWIG_IsOK(res1)) {
9915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9916 }
9917 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9918 {
9919 PyThreadState* __tstate = wxPyBeginAllowThreads();
9920 delete arg1;
9921
9922 wxPyEndAllowThreads(__tstate);
9923 if (PyErr_Occurred()) SWIG_fail;
9924 }
9925 resultobj = SWIG_Py_Void();
9926 return resultobj;
9927 fail:
9928 return NULL;
9929 }
9930
9931
9932 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9933 PyObject *obj;
9934 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9935 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9936 return SWIG_Py_Void();
9937 }
9938
9939 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9940 PyObject *resultobj = 0;
9941 wxPyFileSystemHandler *result = 0 ;
9942
9943 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9944 {
9945 PyThreadState* __tstate = wxPyBeginAllowThreads();
9946 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9947 wxPyEndAllowThreads(__tstate);
9948 if (PyErr_Occurred()) SWIG_fail;
9949 }
9950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9951 return resultobj;
9952 fail:
9953 return NULL;
9954 }
9955
9956
9957 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9958 PyObject *resultobj = 0;
9959 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9960 PyObject *arg2 = (PyObject *) 0 ;
9961 PyObject *arg3 = (PyObject *) 0 ;
9962 void *argp1 = 0 ;
9963 int res1 = 0 ;
9964 PyObject * obj0 = 0 ;
9965 PyObject * obj1 = 0 ;
9966 PyObject * obj2 = 0 ;
9967 char * kwnames[] = {
9968 (char *) "self",(char *) "self",(char *) "_class", NULL
9969 };
9970
9971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9973 if (!SWIG_IsOK(res1)) {
9974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9975 }
9976 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9977 arg2 = obj1;
9978 arg3 = obj2;
9979 {
9980 PyThreadState* __tstate = wxPyBeginAllowThreads();
9981 (arg1)->_setCallbackInfo(arg2,arg3);
9982 wxPyEndAllowThreads(__tstate);
9983 if (PyErr_Occurred()) SWIG_fail;
9984 }
9985 resultobj = SWIG_Py_Void();
9986 return resultobj;
9987 fail:
9988 return NULL;
9989 }
9990
9991
9992 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9993 PyObject *resultobj = 0;
9994 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9995 wxString *arg2 = 0 ;
9996 bool result;
9997 void *argp1 = 0 ;
9998 int res1 = 0 ;
9999 bool temp2 = false ;
10000 PyObject * obj0 = 0 ;
10001 PyObject * obj1 = 0 ;
10002 char * kwnames[] = {
10003 (char *) "self",(char *) "location", NULL
10004 };
10005
10006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10008 if (!SWIG_IsOK(res1)) {
10009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10010 }
10011 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10012 {
10013 arg2 = wxString_in_helper(obj1);
10014 if (arg2 == NULL) SWIG_fail;
10015 temp2 = true;
10016 }
10017 {
10018 PyThreadState* __tstate = wxPyBeginAllowThreads();
10019 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10020 wxPyEndAllowThreads(__tstate);
10021 if (PyErr_Occurred()) SWIG_fail;
10022 }
10023 {
10024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10025 }
10026 {
10027 if (temp2)
10028 delete arg2;
10029 }
10030 return resultobj;
10031 fail:
10032 {
10033 if (temp2)
10034 delete arg2;
10035 }
10036 return NULL;
10037 }
10038
10039
10040 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10041 PyObject *resultobj = 0;
10042 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10043 wxFileSystem *arg2 = 0 ;
10044 wxString *arg3 = 0 ;
10045 wxFSFile *result = 0 ;
10046 void *argp1 = 0 ;
10047 int res1 = 0 ;
10048 void *argp2 = 0 ;
10049 int res2 = 0 ;
10050 bool temp3 = false ;
10051 PyObject * obj0 = 0 ;
10052 PyObject * obj1 = 0 ;
10053 PyObject * obj2 = 0 ;
10054 char * kwnames[] = {
10055 (char *) "self",(char *) "fs",(char *) "location", NULL
10056 };
10057
10058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10060 if (!SWIG_IsOK(res1)) {
10061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10062 }
10063 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10064 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10065 if (!SWIG_IsOK(res2)) {
10066 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10067 }
10068 if (!argp2) {
10069 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10070 }
10071 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10072 {
10073 arg3 = wxString_in_helper(obj2);
10074 if (arg3 == NULL) SWIG_fail;
10075 temp3 = true;
10076 }
10077 {
10078 PyThreadState* __tstate = wxPyBeginAllowThreads();
10079 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10080 wxPyEndAllowThreads(__tstate);
10081 if (PyErr_Occurred()) SWIG_fail;
10082 }
10083 {
10084 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10085 }
10086 {
10087 if (temp3)
10088 delete arg3;
10089 }
10090 return resultobj;
10091 fail:
10092 {
10093 if (temp3)
10094 delete arg3;
10095 }
10096 return NULL;
10097 }
10098
10099
10100 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10101 PyObject *resultobj = 0;
10102 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10103 wxString *arg2 = 0 ;
10104 int arg3 = (int) 0 ;
10105 wxString result;
10106 void *argp1 = 0 ;
10107 int res1 = 0 ;
10108 bool temp2 = false ;
10109 int val3 ;
10110 int ecode3 = 0 ;
10111 PyObject * obj0 = 0 ;
10112 PyObject * obj1 = 0 ;
10113 PyObject * obj2 = 0 ;
10114 char * kwnames[] = {
10115 (char *) "self",(char *) "spec",(char *) "flags", NULL
10116 };
10117
10118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10120 if (!SWIG_IsOK(res1)) {
10121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10122 }
10123 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10124 {
10125 arg2 = wxString_in_helper(obj1);
10126 if (arg2 == NULL) SWIG_fail;
10127 temp2 = true;
10128 }
10129 if (obj2) {
10130 ecode3 = SWIG_AsVal_int(obj2, &val3);
10131 if (!SWIG_IsOK(ecode3)) {
10132 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10133 }
10134 arg3 = static_cast< int >(val3);
10135 }
10136 {
10137 PyThreadState* __tstate = wxPyBeginAllowThreads();
10138 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10139 wxPyEndAllowThreads(__tstate);
10140 if (PyErr_Occurred()) SWIG_fail;
10141 }
10142 {
10143 #if wxUSE_UNICODE
10144 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10145 #else
10146 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10147 #endif
10148 }
10149 {
10150 if (temp2)
10151 delete arg2;
10152 }
10153 return resultobj;
10154 fail:
10155 {
10156 if (temp2)
10157 delete arg2;
10158 }
10159 return NULL;
10160 }
10161
10162
10163 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10164 PyObject *resultobj = 0;
10165 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10166 wxString result;
10167 void *argp1 = 0 ;
10168 int res1 = 0 ;
10169 PyObject *swig_obj[1] ;
10170
10171 if (!args) SWIG_fail;
10172 swig_obj[0] = args;
10173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10174 if (!SWIG_IsOK(res1)) {
10175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10176 }
10177 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10178 {
10179 PyThreadState* __tstate = wxPyBeginAllowThreads();
10180 result = (arg1)->FindNext();
10181 wxPyEndAllowThreads(__tstate);
10182 if (PyErr_Occurred()) SWIG_fail;
10183 }
10184 {
10185 #if wxUSE_UNICODE
10186 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10187 #else
10188 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10189 #endif
10190 }
10191 return resultobj;
10192 fail:
10193 return NULL;
10194 }
10195
10196
10197 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10198 PyObject *resultobj = 0;
10199 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10200 wxString *arg2 = 0 ;
10201 wxString result;
10202 void *argp1 = 0 ;
10203 int res1 = 0 ;
10204 bool temp2 = false ;
10205 PyObject * obj0 = 0 ;
10206 PyObject * obj1 = 0 ;
10207 char * kwnames[] = {
10208 (char *) "self",(char *) "location", NULL
10209 };
10210
10211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10213 if (!SWIG_IsOK(res1)) {
10214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10215 }
10216 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10217 {
10218 arg2 = wxString_in_helper(obj1);
10219 if (arg2 == NULL) SWIG_fail;
10220 temp2 = true;
10221 }
10222 {
10223 PyThreadState* __tstate = wxPyBeginAllowThreads();
10224 result = (arg1)->GetProtocol((wxString const &)*arg2);
10225 wxPyEndAllowThreads(__tstate);
10226 if (PyErr_Occurred()) SWIG_fail;
10227 }
10228 {
10229 #if wxUSE_UNICODE
10230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10231 #else
10232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10233 #endif
10234 }
10235 {
10236 if (temp2)
10237 delete arg2;
10238 }
10239 return resultobj;
10240 fail:
10241 {
10242 if (temp2)
10243 delete arg2;
10244 }
10245 return NULL;
10246 }
10247
10248
10249 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10250 PyObject *resultobj = 0;
10251 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10252 wxString *arg2 = 0 ;
10253 wxString result;
10254 void *argp1 = 0 ;
10255 int res1 = 0 ;
10256 bool temp2 = false ;
10257 PyObject * obj0 = 0 ;
10258 PyObject * obj1 = 0 ;
10259 char * kwnames[] = {
10260 (char *) "self",(char *) "location", NULL
10261 };
10262
10263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10265 if (!SWIG_IsOK(res1)) {
10266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10267 }
10268 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10269 {
10270 arg2 = wxString_in_helper(obj1);
10271 if (arg2 == NULL) SWIG_fail;
10272 temp2 = true;
10273 }
10274 {
10275 PyThreadState* __tstate = wxPyBeginAllowThreads();
10276 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10277 wxPyEndAllowThreads(__tstate);
10278 if (PyErr_Occurred()) SWIG_fail;
10279 }
10280 {
10281 #if wxUSE_UNICODE
10282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10283 #else
10284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10285 #endif
10286 }
10287 {
10288 if (temp2)
10289 delete arg2;
10290 }
10291 return resultobj;
10292 fail:
10293 {
10294 if (temp2)
10295 delete arg2;
10296 }
10297 return NULL;
10298 }
10299
10300
10301 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10302 PyObject *resultobj = 0;
10303 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10304 wxString *arg2 = 0 ;
10305 wxString result;
10306 void *argp1 = 0 ;
10307 int res1 = 0 ;
10308 bool temp2 = false ;
10309 PyObject * obj0 = 0 ;
10310 PyObject * obj1 = 0 ;
10311 char * kwnames[] = {
10312 (char *) "self",(char *) "location", NULL
10313 };
10314
10315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10317 if (!SWIG_IsOK(res1)) {
10318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10319 }
10320 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10321 {
10322 arg2 = wxString_in_helper(obj1);
10323 if (arg2 == NULL) SWIG_fail;
10324 temp2 = true;
10325 }
10326 {
10327 PyThreadState* __tstate = wxPyBeginAllowThreads();
10328 result = (arg1)->GetAnchor((wxString const &)*arg2);
10329 wxPyEndAllowThreads(__tstate);
10330 if (PyErr_Occurred()) SWIG_fail;
10331 }
10332 {
10333 #if wxUSE_UNICODE
10334 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10335 #else
10336 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10337 #endif
10338 }
10339 {
10340 if (temp2)
10341 delete arg2;
10342 }
10343 return resultobj;
10344 fail:
10345 {
10346 if (temp2)
10347 delete arg2;
10348 }
10349 return NULL;
10350 }
10351
10352
10353 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10354 PyObject *resultobj = 0;
10355 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10356 wxString *arg2 = 0 ;
10357 wxString result;
10358 void *argp1 = 0 ;
10359 int res1 = 0 ;
10360 bool temp2 = false ;
10361 PyObject * obj0 = 0 ;
10362 PyObject * obj1 = 0 ;
10363 char * kwnames[] = {
10364 (char *) "self",(char *) "location", NULL
10365 };
10366
10367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10369 if (!SWIG_IsOK(res1)) {
10370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10371 }
10372 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10373 {
10374 arg2 = wxString_in_helper(obj1);
10375 if (arg2 == NULL) SWIG_fail;
10376 temp2 = true;
10377 }
10378 {
10379 PyThreadState* __tstate = wxPyBeginAllowThreads();
10380 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10381 wxPyEndAllowThreads(__tstate);
10382 if (PyErr_Occurred()) SWIG_fail;
10383 }
10384 {
10385 #if wxUSE_UNICODE
10386 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10387 #else
10388 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10389 #endif
10390 }
10391 {
10392 if (temp2)
10393 delete arg2;
10394 }
10395 return resultobj;
10396 fail:
10397 {
10398 if (temp2)
10399 delete arg2;
10400 }
10401 return NULL;
10402 }
10403
10404
10405 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10406 PyObject *resultobj = 0;
10407 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10408 wxString *arg2 = 0 ;
10409 wxString result;
10410 void *argp1 = 0 ;
10411 int res1 = 0 ;
10412 bool temp2 = false ;
10413 PyObject * obj0 = 0 ;
10414 PyObject * obj1 = 0 ;
10415 char * kwnames[] = {
10416 (char *) "self",(char *) "location", NULL
10417 };
10418
10419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10421 if (!SWIG_IsOK(res1)) {
10422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10423 }
10424 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10425 {
10426 arg2 = wxString_in_helper(obj1);
10427 if (arg2 == NULL) SWIG_fail;
10428 temp2 = true;
10429 }
10430 {
10431 PyThreadState* __tstate = wxPyBeginAllowThreads();
10432 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10433 wxPyEndAllowThreads(__tstate);
10434 if (PyErr_Occurred()) SWIG_fail;
10435 }
10436 {
10437 #if wxUSE_UNICODE
10438 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10439 #else
10440 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10441 #endif
10442 }
10443 {
10444 if (temp2)
10445 delete arg2;
10446 }
10447 return resultobj;
10448 fail:
10449 {
10450 if (temp2)
10451 delete arg2;
10452 }
10453 return NULL;
10454 }
10455
10456
10457 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10458 PyObject *obj;
10459 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10460 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10461 return SWIG_Py_Void();
10462 }
10463
10464 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10465 return SWIG_Python_InitShadowInstance(args);
10466 }
10467
10468 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10469 PyObject *resultobj = 0;
10470 wxFileSystem *result = 0 ;
10471
10472 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10473 {
10474 PyThreadState* __tstate = wxPyBeginAllowThreads();
10475 result = (wxFileSystem *)new wxFileSystem();
10476 wxPyEndAllowThreads(__tstate);
10477 if (PyErr_Occurred()) SWIG_fail;
10478 }
10479 {
10480 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10481 }
10482 return resultobj;
10483 fail:
10484 return NULL;
10485 }
10486
10487
10488 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10489 PyObject *resultobj = 0;
10490 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10491 void *argp1 = 0 ;
10492 int res1 = 0 ;
10493 PyObject *swig_obj[1] ;
10494
10495 if (!args) SWIG_fail;
10496 swig_obj[0] = args;
10497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10498 if (!SWIG_IsOK(res1)) {
10499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10500 }
10501 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10502 {
10503 PyThreadState* __tstate = wxPyBeginAllowThreads();
10504 delete arg1;
10505
10506 wxPyEndAllowThreads(__tstate);
10507 if (PyErr_Occurred()) SWIG_fail;
10508 }
10509 resultobj = SWIG_Py_Void();
10510 return resultobj;
10511 fail:
10512 return NULL;
10513 }
10514
10515
10516 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10517 PyObject *resultobj = 0;
10518 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10519 wxString *arg2 = 0 ;
10520 bool arg3 = (bool) false ;
10521 void *argp1 = 0 ;
10522 int res1 = 0 ;
10523 bool temp2 = false ;
10524 bool val3 ;
10525 int ecode3 = 0 ;
10526 PyObject * obj0 = 0 ;
10527 PyObject * obj1 = 0 ;
10528 PyObject * obj2 = 0 ;
10529 char * kwnames[] = {
10530 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10531 };
10532
10533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10535 if (!SWIG_IsOK(res1)) {
10536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10537 }
10538 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10539 {
10540 arg2 = wxString_in_helper(obj1);
10541 if (arg2 == NULL) SWIG_fail;
10542 temp2 = true;
10543 }
10544 if (obj2) {
10545 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10546 if (!SWIG_IsOK(ecode3)) {
10547 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10548 }
10549 arg3 = static_cast< bool >(val3);
10550 }
10551 {
10552 PyThreadState* __tstate = wxPyBeginAllowThreads();
10553 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10554 wxPyEndAllowThreads(__tstate);
10555 if (PyErr_Occurred()) SWIG_fail;
10556 }
10557 resultobj = SWIG_Py_Void();
10558 {
10559 if (temp2)
10560 delete arg2;
10561 }
10562 return resultobj;
10563 fail:
10564 {
10565 if (temp2)
10566 delete arg2;
10567 }
10568 return NULL;
10569 }
10570
10571
10572 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10573 PyObject *resultobj = 0;
10574 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10575 wxString result;
10576 void *argp1 = 0 ;
10577 int res1 = 0 ;
10578 PyObject *swig_obj[1] ;
10579
10580 if (!args) SWIG_fail;
10581 swig_obj[0] = args;
10582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10583 if (!SWIG_IsOK(res1)) {
10584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10585 }
10586 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10587 {
10588 PyThreadState* __tstate = wxPyBeginAllowThreads();
10589 result = (arg1)->GetPath();
10590 wxPyEndAllowThreads(__tstate);
10591 if (PyErr_Occurred()) SWIG_fail;
10592 }
10593 {
10594 #if wxUSE_UNICODE
10595 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10596 #else
10597 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10598 #endif
10599 }
10600 return resultobj;
10601 fail:
10602 return NULL;
10603 }
10604
10605
10606 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10607 PyObject *resultobj = 0;
10608 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10609 wxString *arg2 = 0 ;
10610 wxFSFile *result = 0 ;
10611 void *argp1 = 0 ;
10612 int res1 = 0 ;
10613 bool temp2 = false ;
10614 PyObject * obj0 = 0 ;
10615 PyObject * obj1 = 0 ;
10616 char * kwnames[] = {
10617 (char *) "self",(char *) "location", NULL
10618 };
10619
10620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10622 if (!SWIG_IsOK(res1)) {
10623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10624 }
10625 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10626 {
10627 arg2 = wxString_in_helper(obj1);
10628 if (arg2 == NULL) SWIG_fail;
10629 temp2 = true;
10630 }
10631 {
10632 PyThreadState* __tstate = wxPyBeginAllowThreads();
10633 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10634 wxPyEndAllowThreads(__tstate);
10635 if (PyErr_Occurred()) SWIG_fail;
10636 }
10637 {
10638 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10639 }
10640 {
10641 if (temp2)
10642 delete arg2;
10643 }
10644 return resultobj;
10645 fail:
10646 {
10647 if (temp2)
10648 delete arg2;
10649 }
10650 return NULL;
10651 }
10652
10653
10654 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10655 PyObject *resultobj = 0;
10656 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10657 wxString *arg2 = 0 ;
10658 int arg3 = (int) 0 ;
10659 wxString result;
10660 void *argp1 = 0 ;
10661 int res1 = 0 ;
10662 bool temp2 = false ;
10663 int val3 ;
10664 int ecode3 = 0 ;
10665 PyObject * obj0 = 0 ;
10666 PyObject * obj1 = 0 ;
10667 PyObject * obj2 = 0 ;
10668 char * kwnames[] = {
10669 (char *) "self",(char *) "spec",(char *) "flags", NULL
10670 };
10671
10672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10674 if (!SWIG_IsOK(res1)) {
10675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10676 }
10677 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10678 {
10679 arg2 = wxString_in_helper(obj1);
10680 if (arg2 == NULL) SWIG_fail;
10681 temp2 = true;
10682 }
10683 if (obj2) {
10684 ecode3 = SWIG_AsVal_int(obj2, &val3);
10685 if (!SWIG_IsOK(ecode3)) {
10686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10687 }
10688 arg3 = static_cast< int >(val3);
10689 }
10690 {
10691 PyThreadState* __tstate = wxPyBeginAllowThreads();
10692 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10693 wxPyEndAllowThreads(__tstate);
10694 if (PyErr_Occurred()) SWIG_fail;
10695 }
10696 {
10697 #if wxUSE_UNICODE
10698 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10699 #else
10700 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10701 #endif
10702 }
10703 {
10704 if (temp2)
10705 delete arg2;
10706 }
10707 return resultobj;
10708 fail:
10709 {
10710 if (temp2)
10711 delete arg2;
10712 }
10713 return NULL;
10714 }
10715
10716
10717 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10718 PyObject *resultobj = 0;
10719 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10720 wxString result;
10721 void *argp1 = 0 ;
10722 int res1 = 0 ;
10723 PyObject *swig_obj[1] ;
10724
10725 if (!args) SWIG_fail;
10726 swig_obj[0] = args;
10727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10728 if (!SWIG_IsOK(res1)) {
10729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10730 }
10731 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10732 {
10733 PyThreadState* __tstate = wxPyBeginAllowThreads();
10734 result = (arg1)->FindNext();
10735 wxPyEndAllowThreads(__tstate);
10736 if (PyErr_Occurred()) SWIG_fail;
10737 }
10738 {
10739 #if wxUSE_UNICODE
10740 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10741 #else
10742 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10743 #endif
10744 }
10745 return resultobj;
10746 fail:
10747 return NULL;
10748 }
10749
10750
10751 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10752 PyObject *resultobj = 0;
10753 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10754 int res1 = 0 ;
10755 PyObject * obj0 = 0 ;
10756 char * kwnames[] = {
10757 (char *) "handler", NULL
10758 };
10759
10760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10761 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10762 if (!SWIG_IsOK(res1)) {
10763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10764 }
10765 {
10766 PyThreadState* __tstate = wxPyBeginAllowThreads();
10767 wxFileSystem::AddHandler(arg1);
10768 wxPyEndAllowThreads(__tstate);
10769 if (PyErr_Occurred()) SWIG_fail;
10770 }
10771 resultobj = SWIG_Py_Void();
10772 return resultobj;
10773 fail:
10774 return NULL;
10775 }
10776
10777
10778 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10779 PyObject *resultobj = 0;
10780
10781 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10782 {
10783 PyThreadState* __tstate = wxPyBeginAllowThreads();
10784 wxFileSystem::CleanUpHandlers();
10785 wxPyEndAllowThreads(__tstate);
10786 if (PyErr_Occurred()) SWIG_fail;
10787 }
10788 resultobj = SWIG_Py_Void();
10789 return resultobj;
10790 fail:
10791 return NULL;
10792 }
10793
10794
10795 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10796 PyObject *resultobj = 0;
10797 wxString *arg1 = 0 ;
10798 wxString result;
10799 bool temp1 = false ;
10800 PyObject * obj0 = 0 ;
10801 char * kwnames[] = {
10802 (char *) "filename", NULL
10803 };
10804
10805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10806 {
10807 arg1 = wxString_in_helper(obj0);
10808 if (arg1 == NULL) SWIG_fail;
10809 temp1 = true;
10810 }
10811 {
10812 PyThreadState* __tstate = wxPyBeginAllowThreads();
10813 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10814 wxPyEndAllowThreads(__tstate);
10815 if (PyErr_Occurred()) SWIG_fail;
10816 }
10817 {
10818 #if wxUSE_UNICODE
10819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10820 #else
10821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10822 #endif
10823 }
10824 {
10825 if (temp1)
10826 delete arg1;
10827 }
10828 return resultobj;
10829 fail:
10830 {
10831 if (temp1)
10832 delete arg1;
10833 }
10834 return NULL;
10835 }
10836
10837
10838 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10839 PyObject *resultobj = 0;
10840 wxString *arg1 = 0 ;
10841 wxString result;
10842 bool temp1 = false ;
10843 PyObject * obj0 = 0 ;
10844 char * kwnames[] = {
10845 (char *) "url", NULL
10846 };
10847
10848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10849 {
10850 arg1 = wxString_in_helper(obj0);
10851 if (arg1 == NULL) SWIG_fail;
10852 temp1 = true;
10853 }
10854 {
10855 PyThreadState* __tstate = wxPyBeginAllowThreads();
10856 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10857 wxPyEndAllowThreads(__tstate);
10858 if (PyErr_Occurred()) SWIG_fail;
10859 }
10860 {
10861 #if wxUSE_UNICODE
10862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10863 #else
10864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10865 #endif
10866 }
10867 {
10868 if (temp1)
10869 delete arg1;
10870 }
10871 return resultobj;
10872 fail:
10873 {
10874 if (temp1)
10875 delete arg1;
10876 }
10877 return NULL;
10878 }
10879
10880
10881 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10882 PyObject *obj;
10883 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10884 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10885 return SWIG_Py_Void();
10886 }
10887
10888 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10889 return SWIG_Python_InitShadowInstance(args);
10890 }
10891
10892 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10893 PyObject *resultobj = 0;
10894 wxInternetFSHandler *result = 0 ;
10895
10896 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10897 {
10898 PyThreadState* __tstate = wxPyBeginAllowThreads();
10899 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10900 wxPyEndAllowThreads(__tstate);
10901 if (PyErr_Occurred()) SWIG_fail;
10902 }
10903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10904 return resultobj;
10905 fail:
10906 return NULL;
10907 }
10908
10909
10910 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10911 PyObject *resultobj = 0;
10912 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10913 wxString *arg2 = 0 ;
10914 bool result;
10915 void *argp1 = 0 ;
10916 int res1 = 0 ;
10917 bool temp2 = false ;
10918 PyObject * obj0 = 0 ;
10919 PyObject * obj1 = 0 ;
10920 char * kwnames[] = {
10921 (char *) "self",(char *) "location", NULL
10922 };
10923
10924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10926 if (!SWIG_IsOK(res1)) {
10927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10928 }
10929 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10930 {
10931 arg2 = wxString_in_helper(obj1);
10932 if (arg2 == NULL) SWIG_fail;
10933 temp2 = true;
10934 }
10935 {
10936 PyThreadState* __tstate = wxPyBeginAllowThreads();
10937 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10938 wxPyEndAllowThreads(__tstate);
10939 if (PyErr_Occurred()) SWIG_fail;
10940 }
10941 {
10942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10943 }
10944 {
10945 if (temp2)
10946 delete arg2;
10947 }
10948 return resultobj;
10949 fail:
10950 {
10951 if (temp2)
10952 delete arg2;
10953 }
10954 return NULL;
10955 }
10956
10957
10958 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10959 PyObject *resultobj = 0;
10960 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10961 wxFileSystem *arg2 = 0 ;
10962 wxString *arg3 = 0 ;
10963 wxFSFile *result = 0 ;
10964 void *argp1 = 0 ;
10965 int res1 = 0 ;
10966 void *argp2 = 0 ;
10967 int res2 = 0 ;
10968 bool temp3 = false ;
10969 PyObject * obj0 = 0 ;
10970 PyObject * obj1 = 0 ;
10971 PyObject * obj2 = 0 ;
10972 char * kwnames[] = {
10973 (char *) "self",(char *) "fs",(char *) "location", NULL
10974 };
10975
10976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10978 if (!SWIG_IsOK(res1)) {
10979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10980 }
10981 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10982 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10983 if (!SWIG_IsOK(res2)) {
10984 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10985 }
10986 if (!argp2) {
10987 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10988 }
10989 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10990 {
10991 arg3 = wxString_in_helper(obj2);
10992 if (arg3 == NULL) SWIG_fail;
10993 temp3 = true;
10994 }
10995 {
10996 PyThreadState* __tstate = wxPyBeginAllowThreads();
10997 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10998 wxPyEndAllowThreads(__tstate);
10999 if (PyErr_Occurred()) SWIG_fail;
11000 }
11001 {
11002 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11003 }
11004 {
11005 if (temp3)
11006 delete arg3;
11007 }
11008 return resultobj;
11009 fail:
11010 {
11011 if (temp3)
11012 delete arg3;
11013 }
11014 return NULL;
11015 }
11016
11017
11018 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11019 PyObject *obj;
11020 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11021 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11022 return SWIG_Py_Void();
11023 }
11024
11025 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11026 return SWIG_Python_InitShadowInstance(args);
11027 }
11028
11029 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11030 PyObject *resultobj = 0;
11031 wxZipFSHandler *result = 0 ;
11032
11033 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11034 {
11035 PyThreadState* __tstate = wxPyBeginAllowThreads();
11036 result = (wxZipFSHandler *)new wxZipFSHandler();
11037 wxPyEndAllowThreads(__tstate);
11038 if (PyErr_Occurred()) SWIG_fail;
11039 }
11040 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11041 return resultobj;
11042 fail:
11043 return NULL;
11044 }
11045
11046
11047 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11048 PyObject *resultobj = 0;
11049 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11050 wxString *arg2 = 0 ;
11051 bool result;
11052 void *argp1 = 0 ;
11053 int res1 = 0 ;
11054 bool temp2 = false ;
11055 PyObject * obj0 = 0 ;
11056 PyObject * obj1 = 0 ;
11057 char * kwnames[] = {
11058 (char *) "self",(char *) "location", NULL
11059 };
11060
11061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11063 if (!SWIG_IsOK(res1)) {
11064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11065 }
11066 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11067 {
11068 arg2 = wxString_in_helper(obj1);
11069 if (arg2 == NULL) SWIG_fail;
11070 temp2 = true;
11071 }
11072 {
11073 PyThreadState* __tstate = wxPyBeginAllowThreads();
11074 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11075 wxPyEndAllowThreads(__tstate);
11076 if (PyErr_Occurred()) SWIG_fail;
11077 }
11078 {
11079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11080 }
11081 {
11082 if (temp2)
11083 delete arg2;
11084 }
11085 return resultobj;
11086 fail:
11087 {
11088 if (temp2)
11089 delete arg2;
11090 }
11091 return NULL;
11092 }
11093
11094
11095 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11096 PyObject *resultobj = 0;
11097 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11098 wxFileSystem *arg2 = 0 ;
11099 wxString *arg3 = 0 ;
11100 wxFSFile *result = 0 ;
11101 void *argp1 = 0 ;
11102 int res1 = 0 ;
11103 void *argp2 = 0 ;
11104 int res2 = 0 ;
11105 bool temp3 = false ;
11106 PyObject * obj0 = 0 ;
11107 PyObject * obj1 = 0 ;
11108 PyObject * obj2 = 0 ;
11109 char * kwnames[] = {
11110 (char *) "self",(char *) "fs",(char *) "location", NULL
11111 };
11112
11113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11115 if (!SWIG_IsOK(res1)) {
11116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11117 }
11118 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11119 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11120 if (!SWIG_IsOK(res2)) {
11121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11122 }
11123 if (!argp2) {
11124 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11125 }
11126 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11127 {
11128 arg3 = wxString_in_helper(obj2);
11129 if (arg3 == NULL) SWIG_fail;
11130 temp3 = true;
11131 }
11132 {
11133 PyThreadState* __tstate = wxPyBeginAllowThreads();
11134 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11135 wxPyEndAllowThreads(__tstate);
11136 if (PyErr_Occurred()) SWIG_fail;
11137 }
11138 {
11139 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11140 }
11141 {
11142 if (temp3)
11143 delete arg3;
11144 }
11145 return resultobj;
11146 fail:
11147 {
11148 if (temp3)
11149 delete arg3;
11150 }
11151 return NULL;
11152 }
11153
11154
11155 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11156 PyObject *resultobj = 0;
11157 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11158 wxString *arg2 = 0 ;
11159 int arg3 = (int) 0 ;
11160 wxString result;
11161 void *argp1 = 0 ;
11162 int res1 = 0 ;
11163 bool temp2 = false ;
11164 int val3 ;
11165 int ecode3 = 0 ;
11166 PyObject * obj0 = 0 ;
11167 PyObject * obj1 = 0 ;
11168 PyObject * obj2 = 0 ;
11169 char * kwnames[] = {
11170 (char *) "self",(char *) "spec",(char *) "flags", NULL
11171 };
11172
11173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11175 if (!SWIG_IsOK(res1)) {
11176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11177 }
11178 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11179 {
11180 arg2 = wxString_in_helper(obj1);
11181 if (arg2 == NULL) SWIG_fail;
11182 temp2 = true;
11183 }
11184 if (obj2) {
11185 ecode3 = SWIG_AsVal_int(obj2, &val3);
11186 if (!SWIG_IsOK(ecode3)) {
11187 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11188 }
11189 arg3 = static_cast< int >(val3);
11190 }
11191 {
11192 PyThreadState* __tstate = wxPyBeginAllowThreads();
11193 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11194 wxPyEndAllowThreads(__tstate);
11195 if (PyErr_Occurred()) SWIG_fail;
11196 }
11197 {
11198 #if wxUSE_UNICODE
11199 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11200 #else
11201 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11202 #endif
11203 }
11204 {
11205 if (temp2)
11206 delete arg2;
11207 }
11208 return resultobj;
11209 fail:
11210 {
11211 if (temp2)
11212 delete arg2;
11213 }
11214 return NULL;
11215 }
11216
11217
11218 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11219 PyObject *resultobj = 0;
11220 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11221 wxString result;
11222 void *argp1 = 0 ;
11223 int res1 = 0 ;
11224 PyObject *swig_obj[1] ;
11225
11226 if (!args) SWIG_fail;
11227 swig_obj[0] = args;
11228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11229 if (!SWIG_IsOK(res1)) {
11230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11231 }
11232 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11233 {
11234 PyThreadState* __tstate = wxPyBeginAllowThreads();
11235 result = (arg1)->FindNext();
11236 wxPyEndAllowThreads(__tstate);
11237 if (PyErr_Occurred()) SWIG_fail;
11238 }
11239 {
11240 #if wxUSE_UNICODE
11241 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11242 #else
11243 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11244 #endif
11245 }
11246 return resultobj;
11247 fail:
11248 return NULL;
11249 }
11250
11251
11252 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11253 PyObject *obj;
11254 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11255 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11256 return SWIG_Py_Void();
11257 }
11258
11259 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11260 return SWIG_Python_InitShadowInstance(args);
11261 }
11262
11263 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11264 PyObject *resultobj = 0;
11265 wxString *arg1 = 0 ;
11266 wxImage *arg2 = 0 ;
11267 long arg3 ;
11268 bool temp1 = false ;
11269 void *argp2 = 0 ;
11270 int res2 = 0 ;
11271 long val3 ;
11272 int ecode3 = 0 ;
11273 PyObject * obj0 = 0 ;
11274 PyObject * obj1 = 0 ;
11275 PyObject * obj2 = 0 ;
11276 char * kwnames[] = {
11277 (char *) "filename",(char *) "image",(char *) "type", NULL
11278 };
11279
11280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11281 {
11282 arg1 = wxString_in_helper(obj0);
11283 if (arg1 == NULL) SWIG_fail;
11284 temp1 = true;
11285 }
11286 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11287 if (!SWIG_IsOK(res2)) {
11288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11289 }
11290 if (!argp2) {
11291 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11292 }
11293 arg2 = reinterpret_cast< wxImage * >(argp2);
11294 ecode3 = SWIG_AsVal_long(obj2, &val3);
11295 if (!SWIG_IsOK(ecode3)) {
11296 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11297 }
11298 arg3 = static_cast< long >(val3);
11299 {
11300 PyThreadState* __tstate = wxPyBeginAllowThreads();
11301 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11302 wxPyEndAllowThreads(__tstate);
11303 if (PyErr_Occurred()) SWIG_fail;
11304 }
11305 resultobj = SWIG_Py_Void();
11306 {
11307 if (temp1)
11308 delete arg1;
11309 }
11310 return resultobj;
11311 fail:
11312 {
11313 if (temp1)
11314 delete arg1;
11315 }
11316 return NULL;
11317 }
11318
11319
11320 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11321 PyObject *resultobj = 0;
11322 wxString *arg1 = 0 ;
11323 wxBitmap *arg2 = 0 ;
11324 long arg3 ;
11325 bool temp1 = false ;
11326 void *argp2 = 0 ;
11327 int res2 = 0 ;
11328 long val3 ;
11329 int ecode3 = 0 ;
11330 PyObject * obj0 = 0 ;
11331 PyObject * obj1 = 0 ;
11332 PyObject * obj2 = 0 ;
11333 char * kwnames[] = {
11334 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11335 };
11336
11337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11338 {
11339 arg1 = wxString_in_helper(obj0);
11340 if (arg1 == NULL) SWIG_fail;
11341 temp1 = true;
11342 }
11343 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11344 if (!SWIG_IsOK(res2)) {
11345 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11346 }
11347 if (!argp2) {
11348 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11349 }
11350 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11351 ecode3 = SWIG_AsVal_long(obj2, &val3);
11352 if (!SWIG_IsOK(ecode3)) {
11353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11354 }
11355 arg3 = static_cast< long >(val3);
11356 {
11357 PyThreadState* __tstate = wxPyBeginAllowThreads();
11358 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11359 wxPyEndAllowThreads(__tstate);
11360 if (PyErr_Occurred()) SWIG_fail;
11361 }
11362 resultobj = SWIG_Py_Void();
11363 {
11364 if (temp1)
11365 delete arg1;
11366 }
11367 return resultobj;
11368 fail:
11369 {
11370 if (temp1)
11371 delete arg1;
11372 }
11373 return NULL;
11374 }
11375
11376
11377 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11378 PyObject *resultobj = 0;
11379 wxString *arg1 = 0 ;
11380 PyObject *arg2 = (PyObject *) 0 ;
11381 bool temp1 = false ;
11382 PyObject * obj0 = 0 ;
11383 PyObject * obj1 = 0 ;
11384 char * kwnames[] = {
11385 (char *) "filename",(char *) "data", NULL
11386 };
11387
11388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11389 {
11390 arg1 = wxString_in_helper(obj0);
11391 if (arg1 == NULL) SWIG_fail;
11392 temp1 = true;
11393 }
11394 arg2 = obj1;
11395 {
11396 PyThreadState* __tstate = wxPyBeginAllowThreads();
11397 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11398 wxPyEndAllowThreads(__tstate);
11399 if (PyErr_Occurred()) SWIG_fail;
11400 }
11401 resultobj = SWIG_Py_Void();
11402 {
11403 if (temp1)
11404 delete arg1;
11405 }
11406 return resultobj;
11407 fail:
11408 {
11409 if (temp1)
11410 delete arg1;
11411 }
11412 return NULL;
11413 }
11414
11415
11416 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11417 PyObject *resultobj = 0;
11418 wxMemoryFSHandler *result = 0 ;
11419
11420 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11421 {
11422 PyThreadState* __tstate = wxPyBeginAllowThreads();
11423 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11424 wxPyEndAllowThreads(__tstate);
11425 if (PyErr_Occurred()) SWIG_fail;
11426 }
11427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11428 return resultobj;
11429 fail:
11430 return NULL;
11431 }
11432
11433
11434 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11435 PyObject *resultobj = 0;
11436 wxString *arg1 = 0 ;
11437 bool temp1 = false ;
11438 PyObject * obj0 = 0 ;
11439 char * kwnames[] = {
11440 (char *) "filename", NULL
11441 };
11442
11443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11444 {
11445 arg1 = wxString_in_helper(obj0);
11446 if (arg1 == NULL) SWIG_fail;
11447 temp1 = true;
11448 }
11449 {
11450 PyThreadState* __tstate = wxPyBeginAllowThreads();
11451 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11452 wxPyEndAllowThreads(__tstate);
11453 if (PyErr_Occurred()) SWIG_fail;
11454 }
11455 resultobj = SWIG_Py_Void();
11456 {
11457 if (temp1)
11458 delete arg1;
11459 }
11460 return resultobj;
11461 fail:
11462 {
11463 if (temp1)
11464 delete arg1;
11465 }
11466 return NULL;
11467 }
11468
11469
11470 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11471 PyObject *resultobj = 0;
11472 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11473 wxString *arg2 = 0 ;
11474 bool result;
11475 void *argp1 = 0 ;
11476 int res1 = 0 ;
11477 bool temp2 = false ;
11478 PyObject * obj0 = 0 ;
11479 PyObject * obj1 = 0 ;
11480 char * kwnames[] = {
11481 (char *) "self",(char *) "location", NULL
11482 };
11483
11484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11486 if (!SWIG_IsOK(res1)) {
11487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11488 }
11489 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11490 {
11491 arg2 = wxString_in_helper(obj1);
11492 if (arg2 == NULL) SWIG_fail;
11493 temp2 = true;
11494 }
11495 {
11496 PyThreadState* __tstate = wxPyBeginAllowThreads();
11497 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11498 wxPyEndAllowThreads(__tstate);
11499 if (PyErr_Occurred()) SWIG_fail;
11500 }
11501 {
11502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11503 }
11504 {
11505 if (temp2)
11506 delete arg2;
11507 }
11508 return resultobj;
11509 fail:
11510 {
11511 if (temp2)
11512 delete arg2;
11513 }
11514 return NULL;
11515 }
11516
11517
11518 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11519 PyObject *resultobj = 0;
11520 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11521 wxFileSystem *arg2 = 0 ;
11522 wxString *arg3 = 0 ;
11523 wxFSFile *result = 0 ;
11524 void *argp1 = 0 ;
11525 int res1 = 0 ;
11526 void *argp2 = 0 ;
11527 int res2 = 0 ;
11528 bool temp3 = false ;
11529 PyObject * obj0 = 0 ;
11530 PyObject * obj1 = 0 ;
11531 PyObject * obj2 = 0 ;
11532 char * kwnames[] = {
11533 (char *) "self",(char *) "fs",(char *) "location", NULL
11534 };
11535
11536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11538 if (!SWIG_IsOK(res1)) {
11539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11540 }
11541 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11542 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11543 if (!SWIG_IsOK(res2)) {
11544 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11545 }
11546 if (!argp2) {
11547 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11548 }
11549 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11550 {
11551 arg3 = wxString_in_helper(obj2);
11552 if (arg3 == NULL) SWIG_fail;
11553 temp3 = true;
11554 }
11555 {
11556 PyThreadState* __tstate = wxPyBeginAllowThreads();
11557 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11558 wxPyEndAllowThreads(__tstate);
11559 if (PyErr_Occurred()) SWIG_fail;
11560 }
11561 {
11562 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11563 }
11564 {
11565 if (temp3)
11566 delete arg3;
11567 }
11568 return resultobj;
11569 fail:
11570 {
11571 if (temp3)
11572 delete arg3;
11573 }
11574 return NULL;
11575 }
11576
11577
11578 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11579 PyObject *resultobj = 0;
11580 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11581 wxString *arg2 = 0 ;
11582 int arg3 = (int) 0 ;
11583 wxString result;
11584 void *argp1 = 0 ;
11585 int res1 = 0 ;
11586 bool temp2 = false ;
11587 int val3 ;
11588 int ecode3 = 0 ;
11589 PyObject * obj0 = 0 ;
11590 PyObject * obj1 = 0 ;
11591 PyObject * obj2 = 0 ;
11592 char * kwnames[] = {
11593 (char *) "self",(char *) "spec",(char *) "flags", NULL
11594 };
11595
11596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11598 if (!SWIG_IsOK(res1)) {
11599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11600 }
11601 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11602 {
11603 arg2 = wxString_in_helper(obj1);
11604 if (arg2 == NULL) SWIG_fail;
11605 temp2 = true;
11606 }
11607 if (obj2) {
11608 ecode3 = SWIG_AsVal_int(obj2, &val3);
11609 if (!SWIG_IsOK(ecode3)) {
11610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11611 }
11612 arg3 = static_cast< int >(val3);
11613 }
11614 {
11615 PyThreadState* __tstate = wxPyBeginAllowThreads();
11616 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11617 wxPyEndAllowThreads(__tstate);
11618 if (PyErr_Occurred()) SWIG_fail;
11619 }
11620 {
11621 #if wxUSE_UNICODE
11622 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11623 #else
11624 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11625 #endif
11626 }
11627 {
11628 if (temp2)
11629 delete arg2;
11630 }
11631 return resultobj;
11632 fail:
11633 {
11634 if (temp2)
11635 delete arg2;
11636 }
11637 return NULL;
11638 }
11639
11640
11641 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11642 PyObject *resultobj = 0;
11643 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11644 wxString result;
11645 void *argp1 = 0 ;
11646 int res1 = 0 ;
11647 PyObject *swig_obj[1] ;
11648
11649 if (!args) SWIG_fail;
11650 swig_obj[0] = args;
11651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11652 if (!SWIG_IsOK(res1)) {
11653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11654 }
11655 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11656 {
11657 PyThreadState* __tstate = wxPyBeginAllowThreads();
11658 result = (arg1)->FindNext();
11659 wxPyEndAllowThreads(__tstate);
11660 if (PyErr_Occurred()) SWIG_fail;
11661 }
11662 {
11663 #if wxUSE_UNICODE
11664 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11665 #else
11666 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11667 #endif
11668 }
11669 return resultobj;
11670 fail:
11671 return NULL;
11672 }
11673
11674
11675 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11676 PyObject *obj;
11677 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11678 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11679 return SWIG_Py_Void();
11680 }
11681
11682 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11683 return SWIG_Python_InitShadowInstance(args);
11684 }
11685
11686 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11687 PyObject *resultobj = 0;
11688 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11689 wxString result;
11690 void *argp1 = 0 ;
11691 int res1 = 0 ;
11692 PyObject *swig_obj[1] ;
11693
11694 if (!args) SWIG_fail;
11695 swig_obj[0] = args;
11696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11697 if (!SWIG_IsOK(res1)) {
11698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11699 }
11700 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11701 {
11702 PyThreadState* __tstate = wxPyBeginAllowThreads();
11703 result = (arg1)->GetName();
11704 wxPyEndAllowThreads(__tstate);
11705 if (PyErr_Occurred()) SWIG_fail;
11706 }
11707 {
11708 #if wxUSE_UNICODE
11709 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11710 #else
11711 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11712 #endif
11713 }
11714 return resultobj;
11715 fail:
11716 return NULL;
11717 }
11718
11719
11720 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11721 PyObject *resultobj = 0;
11722 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11723 wxString result;
11724 void *argp1 = 0 ;
11725 int res1 = 0 ;
11726 PyObject *swig_obj[1] ;
11727
11728 if (!args) SWIG_fail;
11729 swig_obj[0] = args;
11730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11731 if (!SWIG_IsOK(res1)) {
11732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11733 }
11734 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11735 {
11736 PyThreadState* __tstate = wxPyBeginAllowThreads();
11737 result = (arg1)->GetExtension();
11738 wxPyEndAllowThreads(__tstate);
11739 if (PyErr_Occurred()) SWIG_fail;
11740 }
11741 {
11742 #if wxUSE_UNICODE
11743 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11744 #else
11745 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11746 #endif
11747 }
11748 return resultobj;
11749 fail:
11750 return NULL;
11751 }
11752
11753
11754 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11755 PyObject *resultobj = 0;
11756 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11757 long result;
11758 void *argp1 = 0 ;
11759 int res1 = 0 ;
11760 PyObject *swig_obj[1] ;
11761
11762 if (!args) SWIG_fail;
11763 swig_obj[0] = args;
11764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11765 if (!SWIG_IsOK(res1)) {
11766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11767 }
11768 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11769 {
11770 PyThreadState* __tstate = wxPyBeginAllowThreads();
11771 result = (long)(arg1)->GetType();
11772 wxPyEndAllowThreads(__tstate);
11773 if (PyErr_Occurred()) SWIG_fail;
11774 }
11775 resultobj = SWIG_From_long(static_cast< long >(result));
11776 return resultobj;
11777 fail:
11778 return NULL;
11779 }
11780
11781
11782 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11783 PyObject *resultobj = 0;
11784 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11785 wxString result;
11786 void *argp1 = 0 ;
11787 int res1 = 0 ;
11788 PyObject *swig_obj[1] ;
11789
11790 if (!args) SWIG_fail;
11791 swig_obj[0] = args;
11792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11793 if (!SWIG_IsOK(res1)) {
11794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11795 }
11796 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11797 {
11798 PyThreadState* __tstate = wxPyBeginAllowThreads();
11799 result = (arg1)->GetMimeType();
11800 wxPyEndAllowThreads(__tstate);
11801 if (PyErr_Occurred()) SWIG_fail;
11802 }
11803 {
11804 #if wxUSE_UNICODE
11805 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11806 #else
11807 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11808 #endif
11809 }
11810 return resultobj;
11811 fail:
11812 return NULL;
11813 }
11814
11815
11816 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11817 PyObject *resultobj = 0;
11818 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11819 wxString *arg2 = 0 ;
11820 bool result;
11821 void *argp1 = 0 ;
11822 int res1 = 0 ;
11823 bool temp2 = false ;
11824 PyObject * obj0 = 0 ;
11825 PyObject * obj1 = 0 ;
11826 char * kwnames[] = {
11827 (char *) "self",(char *) "name", NULL
11828 };
11829
11830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11832 if (!SWIG_IsOK(res1)) {
11833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11834 }
11835 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11836 {
11837 arg2 = wxString_in_helper(obj1);
11838 if (arg2 == NULL) SWIG_fail;
11839 temp2 = true;
11840 }
11841 {
11842 PyThreadState* __tstate = wxPyBeginAllowThreads();
11843 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11844 wxPyEndAllowThreads(__tstate);
11845 if (PyErr_Occurred()) SWIG_fail;
11846 }
11847 {
11848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11849 }
11850 {
11851 if (temp2)
11852 delete arg2;
11853 }
11854 return resultobj;
11855 fail:
11856 {
11857 if (temp2)
11858 delete arg2;
11859 }
11860 return NULL;
11861 }
11862
11863
11864 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11865 PyObject *resultobj = 0;
11866 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11867 wxString *arg2 = 0 ;
11868 void *argp1 = 0 ;
11869 int res1 = 0 ;
11870 bool temp2 = false ;
11871 PyObject * obj0 = 0 ;
11872 PyObject * obj1 = 0 ;
11873 char * kwnames[] = {
11874 (char *) "self",(char *) "name", NULL
11875 };
11876
11877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11879 if (!SWIG_IsOK(res1)) {
11880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11881 }
11882 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11883 {
11884 arg2 = wxString_in_helper(obj1);
11885 if (arg2 == NULL) SWIG_fail;
11886 temp2 = true;
11887 }
11888 {
11889 PyThreadState* __tstate = wxPyBeginAllowThreads();
11890 (arg1)->SetName((wxString const &)*arg2);
11891 wxPyEndAllowThreads(__tstate);
11892 if (PyErr_Occurred()) SWIG_fail;
11893 }
11894 resultobj = SWIG_Py_Void();
11895 {
11896 if (temp2)
11897 delete arg2;
11898 }
11899 return resultobj;
11900 fail:
11901 {
11902 if (temp2)
11903 delete arg2;
11904 }
11905 return NULL;
11906 }
11907
11908
11909 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11910 PyObject *resultobj = 0;
11911 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11912 wxString *arg2 = 0 ;
11913 void *argp1 = 0 ;
11914 int res1 = 0 ;
11915 bool temp2 = false ;
11916 PyObject * obj0 = 0 ;
11917 PyObject * obj1 = 0 ;
11918 char * kwnames[] = {
11919 (char *) "self",(char *) "extension", NULL
11920 };
11921
11922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11924 if (!SWIG_IsOK(res1)) {
11925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11926 }
11927 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11928 {
11929 arg2 = wxString_in_helper(obj1);
11930 if (arg2 == NULL) SWIG_fail;
11931 temp2 = true;
11932 }
11933 {
11934 PyThreadState* __tstate = wxPyBeginAllowThreads();
11935 (arg1)->SetExtension((wxString const &)*arg2);
11936 wxPyEndAllowThreads(__tstate);
11937 if (PyErr_Occurred()) SWIG_fail;
11938 }
11939 resultobj = SWIG_Py_Void();
11940 {
11941 if (temp2)
11942 delete arg2;
11943 }
11944 return resultobj;
11945 fail:
11946 {
11947 if (temp2)
11948 delete arg2;
11949 }
11950 return NULL;
11951 }
11952
11953
11954 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11955 PyObject *resultobj = 0;
11956 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11957 long arg2 ;
11958 void *argp1 = 0 ;
11959 int res1 = 0 ;
11960 long val2 ;
11961 int ecode2 = 0 ;
11962 PyObject * obj0 = 0 ;
11963 PyObject * obj1 = 0 ;
11964 char * kwnames[] = {
11965 (char *) "self",(char *) "type", NULL
11966 };
11967
11968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11970 if (!SWIG_IsOK(res1)) {
11971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11972 }
11973 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11974 ecode2 = SWIG_AsVal_long(obj1, &val2);
11975 if (!SWIG_IsOK(ecode2)) {
11976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11977 }
11978 arg2 = static_cast< long >(val2);
11979 {
11980 PyThreadState* __tstate = wxPyBeginAllowThreads();
11981 (arg1)->SetType(arg2);
11982 wxPyEndAllowThreads(__tstate);
11983 if (PyErr_Occurred()) SWIG_fail;
11984 }
11985 resultobj = SWIG_Py_Void();
11986 return resultobj;
11987 fail:
11988 return NULL;
11989 }
11990
11991
11992 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11993 PyObject *resultobj = 0;
11994 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11995 wxString *arg2 = 0 ;
11996 void *argp1 = 0 ;
11997 int res1 = 0 ;
11998 bool temp2 = false ;
11999 PyObject * obj0 = 0 ;
12000 PyObject * obj1 = 0 ;
12001 char * kwnames[] = {
12002 (char *) "self",(char *) "mimetype", NULL
12003 };
12004
12005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12007 if (!SWIG_IsOK(res1)) {
12008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12009 }
12010 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12011 {
12012 arg2 = wxString_in_helper(obj1);
12013 if (arg2 == NULL) SWIG_fail;
12014 temp2 = true;
12015 }
12016 {
12017 PyThreadState* __tstate = wxPyBeginAllowThreads();
12018 (arg1)->SetMimeType((wxString const &)*arg2);
12019 wxPyEndAllowThreads(__tstate);
12020 if (PyErr_Occurred()) SWIG_fail;
12021 }
12022 resultobj = SWIG_Py_Void();
12023 {
12024 if (temp2)
12025 delete arg2;
12026 }
12027 return resultobj;
12028 fail:
12029 {
12030 if (temp2)
12031 delete arg2;
12032 }
12033 return NULL;
12034 }
12035
12036
12037 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12038 PyObject *obj;
12039 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12040 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12041 return SWIG_Py_Void();
12042 }
12043
12044 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12045 PyObject *resultobj = 0;
12046 wxPyImageHandler *result = 0 ;
12047
12048 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12049 {
12050 PyThreadState* __tstate = wxPyBeginAllowThreads();
12051 result = (wxPyImageHandler *)new wxPyImageHandler();
12052 wxPyEndAllowThreads(__tstate);
12053 if (PyErr_Occurred()) SWIG_fail;
12054 }
12055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12056 return resultobj;
12057 fail:
12058 return NULL;
12059 }
12060
12061
12062 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12063 PyObject *resultobj = 0;
12064 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12065 PyObject *arg2 = (PyObject *) 0 ;
12066 void *argp1 = 0 ;
12067 int res1 = 0 ;
12068 PyObject * obj0 = 0 ;
12069 PyObject * obj1 = 0 ;
12070 char * kwnames[] = {
12071 (char *) "self",(char *) "self", NULL
12072 };
12073
12074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12076 if (!SWIG_IsOK(res1)) {
12077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12078 }
12079 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12080 arg2 = obj1;
12081 {
12082 PyThreadState* __tstate = wxPyBeginAllowThreads();
12083 (arg1)->_SetSelf(arg2);
12084 wxPyEndAllowThreads(__tstate);
12085 if (PyErr_Occurred()) SWIG_fail;
12086 }
12087 resultobj = SWIG_Py_Void();
12088 return resultobj;
12089 fail:
12090 return NULL;
12091 }
12092
12093
12094 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12095 PyObject *obj;
12096 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12097 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12098 return SWIG_Py_Void();
12099 }
12100
12101 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12102 return SWIG_Python_InitShadowInstance(args);
12103 }
12104
12105 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12106 PyObject *resultobj = 0;
12107 wxImageHistogram *result = 0 ;
12108
12109 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12110 {
12111 PyThreadState* __tstate = wxPyBeginAllowThreads();
12112 result = (wxImageHistogram *)new wxImageHistogram();
12113 wxPyEndAllowThreads(__tstate);
12114 if (PyErr_Occurred()) SWIG_fail;
12115 }
12116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12117 return resultobj;
12118 fail:
12119 return NULL;
12120 }
12121
12122
12123 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12124 PyObject *resultobj = 0;
12125 byte arg1 ;
12126 byte arg2 ;
12127 byte arg3 ;
12128 unsigned long result;
12129 unsigned char val1 ;
12130 int ecode1 = 0 ;
12131 unsigned char val2 ;
12132 int ecode2 = 0 ;
12133 unsigned char val3 ;
12134 int ecode3 = 0 ;
12135 PyObject * obj0 = 0 ;
12136 PyObject * obj1 = 0 ;
12137 PyObject * obj2 = 0 ;
12138 char * kwnames[] = {
12139 (char *) "r",(char *) "g",(char *) "b", NULL
12140 };
12141
12142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12143 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12144 if (!SWIG_IsOK(ecode1)) {
12145 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12146 }
12147 arg1 = static_cast< byte >(val1);
12148 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12149 if (!SWIG_IsOK(ecode2)) {
12150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12151 }
12152 arg2 = static_cast< byte >(val2);
12153 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12154 if (!SWIG_IsOK(ecode3)) {
12155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12156 }
12157 arg3 = static_cast< byte >(val3);
12158 {
12159 PyThreadState* __tstate = wxPyBeginAllowThreads();
12160 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12161 wxPyEndAllowThreads(__tstate);
12162 if (PyErr_Occurred()) SWIG_fail;
12163 }
12164 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12165 return resultobj;
12166 fail:
12167 return NULL;
12168 }
12169
12170
12171 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12172 PyObject *resultobj = 0;
12173 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12174 byte *arg2 = (byte *) 0 ;
12175 byte *arg3 = (byte *) 0 ;
12176 byte *arg4 = (byte *) 0 ;
12177 byte arg5 = (byte) 1 ;
12178 byte arg6 = (byte) 0 ;
12179 byte arg7 = (byte) 0 ;
12180 bool result;
12181 void *argp1 = 0 ;
12182 int res1 = 0 ;
12183 byte temp2 ;
12184 int res2 = SWIG_TMPOBJ ;
12185 byte temp3 ;
12186 int res3 = SWIG_TMPOBJ ;
12187 byte temp4 ;
12188 int res4 = SWIG_TMPOBJ ;
12189 unsigned char val5 ;
12190 int ecode5 = 0 ;
12191 unsigned char val6 ;
12192 int ecode6 = 0 ;
12193 unsigned char val7 ;
12194 int ecode7 = 0 ;
12195 PyObject * obj0 = 0 ;
12196 PyObject * obj1 = 0 ;
12197 PyObject * obj2 = 0 ;
12198 PyObject * obj3 = 0 ;
12199 char * kwnames[] = {
12200 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12201 };
12202
12203 arg2 = &temp2;
12204 arg3 = &temp3;
12205 arg4 = &temp4;
12206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12208 if (!SWIG_IsOK(res1)) {
12209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12210 }
12211 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12212 if (obj1) {
12213 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12214 if (!SWIG_IsOK(ecode5)) {
12215 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12216 }
12217 arg5 = static_cast< byte >(val5);
12218 }
12219 if (obj2) {
12220 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12221 if (!SWIG_IsOK(ecode6)) {
12222 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12223 }
12224 arg6 = static_cast< byte >(val6);
12225 }
12226 if (obj3) {
12227 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12228 if (!SWIG_IsOK(ecode7)) {
12229 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12230 }
12231 arg7 = static_cast< byte >(val7);
12232 }
12233 {
12234 PyThreadState* __tstate = wxPyBeginAllowThreads();
12235 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12236 wxPyEndAllowThreads(__tstate);
12237 if (PyErr_Occurred()) SWIG_fail;
12238 }
12239 {
12240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12241 }
12242 if (SWIG_IsTmpObj(res2)) {
12243 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12244 } else {
12245 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12246 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12247 }
12248 if (SWIG_IsTmpObj(res3)) {
12249 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12250 } else {
12251 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12252 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12253 }
12254 if (SWIG_IsTmpObj(res4)) {
12255 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12256 } else {
12257 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12258 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12259 }
12260 return resultobj;
12261 fail:
12262 return NULL;
12263 }
12264
12265
12266 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12267 PyObject *resultobj = 0;
12268 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12269 unsigned long arg2 ;
12270 unsigned long result;
12271 void *argp1 = 0 ;
12272 int res1 = 0 ;
12273 unsigned long val2 ;
12274 int ecode2 = 0 ;
12275 PyObject * obj0 = 0 ;
12276 PyObject * obj1 = 0 ;
12277 char * kwnames[] = {
12278 (char *) "self",(char *) "key", NULL
12279 };
12280
12281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12283 if (!SWIG_IsOK(res1)) {
12284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12285 }
12286 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12287 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12288 if (!SWIG_IsOK(ecode2)) {
12289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12290 }
12291 arg2 = static_cast< unsigned long >(val2);
12292 {
12293 PyThreadState* __tstate = wxPyBeginAllowThreads();
12294 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12295 wxPyEndAllowThreads(__tstate);
12296 if (PyErr_Occurred()) SWIG_fail;
12297 }
12298 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12299 return resultobj;
12300 fail:
12301 return NULL;
12302 }
12303
12304
12305 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12306 PyObject *resultobj = 0;
12307 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12308 byte arg2 ;
12309 byte arg3 ;
12310 byte arg4 ;
12311 unsigned long result;
12312 void *argp1 = 0 ;
12313 int res1 = 0 ;
12314 unsigned char val2 ;
12315 int ecode2 = 0 ;
12316 unsigned char val3 ;
12317 int ecode3 = 0 ;
12318 unsigned char val4 ;
12319 int ecode4 = 0 ;
12320 PyObject * obj0 = 0 ;
12321 PyObject * obj1 = 0 ;
12322 PyObject * obj2 = 0 ;
12323 PyObject * obj3 = 0 ;
12324 char * kwnames[] = {
12325 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12326 };
12327
12328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12330 if (!SWIG_IsOK(res1)) {
12331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12332 }
12333 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12334 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12335 if (!SWIG_IsOK(ecode2)) {
12336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12337 }
12338 arg2 = static_cast< byte >(val2);
12339 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12340 if (!SWIG_IsOK(ecode3)) {
12341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12342 }
12343 arg3 = static_cast< byte >(val3);
12344 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12345 if (!SWIG_IsOK(ecode4)) {
12346 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12347 }
12348 arg4 = static_cast< byte >(val4);
12349 {
12350 PyThreadState* __tstate = wxPyBeginAllowThreads();
12351 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12352 wxPyEndAllowThreads(__tstate);
12353 if (PyErr_Occurred()) SWIG_fail;
12354 }
12355 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12356 return resultobj;
12357 fail:
12358 return NULL;
12359 }
12360
12361
12362 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12363 PyObject *resultobj = 0;
12364 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12365 wxColour *arg2 = 0 ;
12366 unsigned long result;
12367 void *argp1 = 0 ;
12368 int res1 = 0 ;
12369 wxColour temp2 ;
12370 PyObject * obj0 = 0 ;
12371 PyObject * obj1 = 0 ;
12372 char * kwnames[] = {
12373 (char *) "self",(char *) "colour", NULL
12374 };
12375
12376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12378 if (!SWIG_IsOK(res1)) {
12379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12380 }
12381 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12382 {
12383 arg2 = &temp2;
12384 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12385 }
12386 {
12387 PyThreadState* __tstate = wxPyBeginAllowThreads();
12388 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12389 wxPyEndAllowThreads(__tstate);
12390 if (PyErr_Occurred()) SWIG_fail;
12391 }
12392 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12393 return resultobj;
12394 fail:
12395 return NULL;
12396 }
12397
12398
12399 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12400 PyObject *obj;
12401 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12402 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12403 return SWIG_Py_Void();
12404 }
12405
12406 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12407 return SWIG_Python_InitShadowInstance(args);
12408 }
12409
12410 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12411 PyObject *resultobj = 0;
12412 byte arg1 = (byte) 0 ;
12413 byte arg2 = (byte) 0 ;
12414 byte arg3 = (byte) 0 ;
12415 wxImage_RGBValue *result = 0 ;
12416 unsigned char val1 ;
12417 int ecode1 = 0 ;
12418 unsigned char val2 ;
12419 int ecode2 = 0 ;
12420 unsigned char val3 ;
12421 int ecode3 = 0 ;
12422 PyObject * obj0 = 0 ;
12423 PyObject * obj1 = 0 ;
12424 PyObject * obj2 = 0 ;
12425 char * kwnames[] = {
12426 (char *) "r",(char *) "g",(char *) "b", NULL
12427 };
12428
12429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12430 if (obj0) {
12431 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12432 if (!SWIG_IsOK(ecode1)) {
12433 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12434 }
12435 arg1 = static_cast< byte >(val1);
12436 }
12437 if (obj1) {
12438 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12439 if (!SWIG_IsOK(ecode2)) {
12440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12441 }
12442 arg2 = static_cast< byte >(val2);
12443 }
12444 if (obj2) {
12445 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12446 if (!SWIG_IsOK(ecode3)) {
12447 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12448 }
12449 arg3 = static_cast< byte >(val3);
12450 }
12451 {
12452 PyThreadState* __tstate = wxPyBeginAllowThreads();
12453 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12454 wxPyEndAllowThreads(__tstate);
12455 if (PyErr_Occurred()) SWIG_fail;
12456 }
12457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12458 return resultobj;
12459 fail:
12460 return NULL;
12461 }
12462
12463
12464 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12465 PyObject *resultobj = 0;
12466 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12467 byte arg2 ;
12468 void *argp1 = 0 ;
12469 int res1 = 0 ;
12470 unsigned char val2 ;
12471 int ecode2 = 0 ;
12472 PyObject *swig_obj[2] ;
12473
12474 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12476 if (!SWIG_IsOK(res1)) {
12477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12478 }
12479 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12480 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12481 if (!SWIG_IsOK(ecode2)) {
12482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12483 }
12484 arg2 = static_cast< byte >(val2);
12485 if (arg1) (arg1)->red = arg2;
12486
12487 resultobj = SWIG_Py_Void();
12488 return resultobj;
12489 fail:
12490 return NULL;
12491 }
12492
12493
12494 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12495 PyObject *resultobj = 0;
12496 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12497 byte result;
12498 void *argp1 = 0 ;
12499 int res1 = 0 ;
12500 PyObject *swig_obj[1] ;
12501
12502 if (!args) SWIG_fail;
12503 swig_obj[0] = args;
12504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12505 if (!SWIG_IsOK(res1)) {
12506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12507 }
12508 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12509 result = (byte) ((arg1)->red);
12510 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12511 return resultobj;
12512 fail:
12513 return NULL;
12514 }
12515
12516
12517 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12518 PyObject *resultobj = 0;
12519 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12520 byte arg2 ;
12521 void *argp1 = 0 ;
12522 int res1 = 0 ;
12523 unsigned char val2 ;
12524 int ecode2 = 0 ;
12525 PyObject *swig_obj[2] ;
12526
12527 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12529 if (!SWIG_IsOK(res1)) {
12530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12531 }
12532 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12533 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12534 if (!SWIG_IsOK(ecode2)) {
12535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12536 }
12537 arg2 = static_cast< byte >(val2);
12538 if (arg1) (arg1)->green = arg2;
12539
12540 resultobj = SWIG_Py_Void();
12541 return resultobj;
12542 fail:
12543 return NULL;
12544 }
12545
12546
12547 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12548 PyObject *resultobj = 0;
12549 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12550 byte result;
12551 void *argp1 = 0 ;
12552 int res1 = 0 ;
12553 PyObject *swig_obj[1] ;
12554
12555 if (!args) SWIG_fail;
12556 swig_obj[0] = args;
12557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12558 if (!SWIG_IsOK(res1)) {
12559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12560 }
12561 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12562 result = (byte) ((arg1)->green);
12563 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12564 return resultobj;
12565 fail:
12566 return NULL;
12567 }
12568
12569
12570 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12571 PyObject *resultobj = 0;
12572 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12573 byte arg2 ;
12574 void *argp1 = 0 ;
12575 int res1 = 0 ;
12576 unsigned char val2 ;
12577 int ecode2 = 0 ;
12578 PyObject *swig_obj[2] ;
12579
12580 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12582 if (!SWIG_IsOK(res1)) {
12583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12584 }
12585 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12586 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12587 if (!SWIG_IsOK(ecode2)) {
12588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12589 }
12590 arg2 = static_cast< byte >(val2);
12591 if (arg1) (arg1)->blue = arg2;
12592
12593 resultobj = SWIG_Py_Void();
12594 return resultobj;
12595 fail:
12596 return NULL;
12597 }
12598
12599
12600 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12601 PyObject *resultobj = 0;
12602 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12603 byte result;
12604 void *argp1 = 0 ;
12605 int res1 = 0 ;
12606 PyObject *swig_obj[1] ;
12607
12608 if (!args) SWIG_fail;
12609 swig_obj[0] = args;
12610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12611 if (!SWIG_IsOK(res1)) {
12612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12613 }
12614 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12615 result = (byte) ((arg1)->blue);
12616 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12617 return resultobj;
12618 fail:
12619 return NULL;
12620 }
12621
12622
12623 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12624 PyObject *obj;
12625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12626 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12627 return SWIG_Py_Void();
12628 }
12629
12630 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12631 return SWIG_Python_InitShadowInstance(args);
12632 }
12633
12634 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12635 PyObject *resultobj = 0;
12636 double arg1 = (double) 0.0 ;
12637 double arg2 = (double) 0.0 ;
12638 double arg3 = (double) 0.0 ;
12639 wxImage_HSVValue *result = 0 ;
12640 double val1 ;
12641 int ecode1 = 0 ;
12642 double val2 ;
12643 int ecode2 = 0 ;
12644 double val3 ;
12645 int ecode3 = 0 ;
12646 PyObject * obj0 = 0 ;
12647 PyObject * obj1 = 0 ;
12648 PyObject * obj2 = 0 ;
12649 char * kwnames[] = {
12650 (char *) "h",(char *) "s",(char *) "v", NULL
12651 };
12652
12653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12654 if (obj0) {
12655 ecode1 = SWIG_AsVal_double(obj0, &val1);
12656 if (!SWIG_IsOK(ecode1)) {
12657 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12658 }
12659 arg1 = static_cast< double >(val1);
12660 }
12661 if (obj1) {
12662 ecode2 = SWIG_AsVal_double(obj1, &val2);
12663 if (!SWIG_IsOK(ecode2)) {
12664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12665 }
12666 arg2 = static_cast< double >(val2);
12667 }
12668 if (obj2) {
12669 ecode3 = SWIG_AsVal_double(obj2, &val3);
12670 if (!SWIG_IsOK(ecode3)) {
12671 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12672 }
12673 arg3 = static_cast< double >(val3);
12674 }
12675 {
12676 PyThreadState* __tstate = wxPyBeginAllowThreads();
12677 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12678 wxPyEndAllowThreads(__tstate);
12679 if (PyErr_Occurred()) SWIG_fail;
12680 }
12681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12682 return resultobj;
12683 fail:
12684 return NULL;
12685 }
12686
12687
12688 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12689 PyObject *resultobj = 0;
12690 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12691 double arg2 ;
12692 void *argp1 = 0 ;
12693 int res1 = 0 ;
12694 double val2 ;
12695 int ecode2 = 0 ;
12696 PyObject *swig_obj[2] ;
12697
12698 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12700 if (!SWIG_IsOK(res1)) {
12701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12702 }
12703 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12704 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12705 if (!SWIG_IsOK(ecode2)) {
12706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12707 }
12708 arg2 = static_cast< double >(val2);
12709 if (arg1) (arg1)->hue = arg2;
12710
12711 resultobj = SWIG_Py_Void();
12712 return resultobj;
12713 fail:
12714 return NULL;
12715 }
12716
12717
12718 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12719 PyObject *resultobj = 0;
12720 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12721 double result;
12722 void *argp1 = 0 ;
12723 int res1 = 0 ;
12724 PyObject *swig_obj[1] ;
12725
12726 if (!args) SWIG_fail;
12727 swig_obj[0] = args;
12728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12729 if (!SWIG_IsOK(res1)) {
12730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12731 }
12732 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12733 result = (double) ((arg1)->hue);
12734 resultobj = SWIG_From_double(static_cast< double >(result));
12735 return resultobj;
12736 fail:
12737 return NULL;
12738 }
12739
12740
12741 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12742 PyObject *resultobj = 0;
12743 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12744 double arg2 ;
12745 void *argp1 = 0 ;
12746 int res1 = 0 ;
12747 double val2 ;
12748 int ecode2 = 0 ;
12749 PyObject *swig_obj[2] ;
12750
12751 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12753 if (!SWIG_IsOK(res1)) {
12754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12755 }
12756 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12757 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12758 if (!SWIG_IsOK(ecode2)) {
12759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12760 }
12761 arg2 = static_cast< double >(val2);
12762 if (arg1) (arg1)->saturation = arg2;
12763
12764 resultobj = SWIG_Py_Void();
12765 return resultobj;
12766 fail:
12767 return NULL;
12768 }
12769
12770
12771 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12772 PyObject *resultobj = 0;
12773 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12774 double result;
12775 void *argp1 = 0 ;
12776 int res1 = 0 ;
12777 PyObject *swig_obj[1] ;
12778
12779 if (!args) SWIG_fail;
12780 swig_obj[0] = args;
12781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12782 if (!SWIG_IsOK(res1)) {
12783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12784 }
12785 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12786 result = (double) ((arg1)->saturation);
12787 resultobj = SWIG_From_double(static_cast< double >(result));
12788 return resultobj;
12789 fail:
12790 return NULL;
12791 }
12792
12793
12794 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12795 PyObject *resultobj = 0;
12796 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12797 double arg2 ;
12798 void *argp1 = 0 ;
12799 int res1 = 0 ;
12800 double val2 ;
12801 int ecode2 = 0 ;
12802 PyObject *swig_obj[2] ;
12803
12804 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12806 if (!SWIG_IsOK(res1)) {
12807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12808 }
12809 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12810 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12811 if (!SWIG_IsOK(ecode2)) {
12812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12813 }
12814 arg2 = static_cast< double >(val2);
12815 if (arg1) (arg1)->value = arg2;
12816
12817 resultobj = SWIG_Py_Void();
12818 return resultobj;
12819 fail:
12820 return NULL;
12821 }
12822
12823
12824 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12825 PyObject *resultobj = 0;
12826 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12827 double result;
12828 void *argp1 = 0 ;
12829 int res1 = 0 ;
12830 PyObject *swig_obj[1] ;
12831
12832 if (!args) SWIG_fail;
12833 swig_obj[0] = args;
12834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12835 if (!SWIG_IsOK(res1)) {
12836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12837 }
12838 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12839 result = (double) ((arg1)->value);
12840 resultobj = SWIG_From_double(static_cast< double >(result));
12841 return resultobj;
12842 fail:
12843 return NULL;
12844 }
12845
12846
12847 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12848 PyObject *obj;
12849 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12850 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12851 return SWIG_Py_Void();
12852 }
12853
12854 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12855 return SWIG_Python_InitShadowInstance(args);
12856 }
12857
12858 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12859 PyObject *resultobj = 0;
12860 wxString *arg1 = 0 ;
12861 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12862 int arg3 = (int) -1 ;
12863 wxImage *result = 0 ;
12864 bool temp1 = false ;
12865 long val2 ;
12866 int ecode2 = 0 ;
12867 int val3 ;
12868 int ecode3 = 0 ;
12869 PyObject * obj0 = 0 ;
12870 PyObject * obj1 = 0 ;
12871 PyObject * obj2 = 0 ;
12872 char * kwnames[] = {
12873 (char *) "name",(char *) "type",(char *) "index", NULL
12874 };
12875
12876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12877 {
12878 arg1 = wxString_in_helper(obj0);
12879 if (arg1 == NULL) SWIG_fail;
12880 temp1 = true;
12881 }
12882 if (obj1) {
12883 ecode2 = SWIG_AsVal_long(obj1, &val2);
12884 if (!SWIG_IsOK(ecode2)) {
12885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12886 }
12887 arg2 = static_cast< long >(val2);
12888 }
12889 if (obj2) {
12890 ecode3 = SWIG_AsVal_int(obj2, &val3);
12891 if (!SWIG_IsOK(ecode3)) {
12892 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12893 }
12894 arg3 = static_cast< int >(val3);
12895 }
12896 {
12897 PyThreadState* __tstate = wxPyBeginAllowThreads();
12898 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12899 wxPyEndAllowThreads(__tstate);
12900 if (PyErr_Occurred()) SWIG_fail;
12901 }
12902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12903 {
12904 if (temp1)
12905 delete arg1;
12906 }
12907 return resultobj;
12908 fail:
12909 {
12910 if (temp1)
12911 delete arg1;
12912 }
12913 return NULL;
12914 }
12915
12916
12917 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12918 PyObject *resultobj = 0;
12919 wxImage *arg1 = (wxImage *) 0 ;
12920 void *argp1 = 0 ;
12921 int res1 = 0 ;
12922 PyObject *swig_obj[1] ;
12923
12924 if (!args) SWIG_fail;
12925 swig_obj[0] = args;
12926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12927 if (!SWIG_IsOK(res1)) {
12928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12929 }
12930 arg1 = reinterpret_cast< wxImage * >(argp1);
12931 {
12932 PyThreadState* __tstate = wxPyBeginAllowThreads();
12933 delete arg1;
12934
12935 wxPyEndAllowThreads(__tstate);
12936 if (PyErr_Occurred()) SWIG_fail;
12937 }
12938 resultobj = SWIG_Py_Void();
12939 return resultobj;
12940 fail:
12941 return NULL;
12942 }
12943
12944
12945 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12946 PyObject *resultobj = 0;
12947 wxString *arg1 = 0 ;
12948 wxString *arg2 = 0 ;
12949 int arg3 = (int) -1 ;
12950 wxImage *result = 0 ;
12951 bool temp1 = false ;
12952 bool temp2 = false ;
12953 int val3 ;
12954 int ecode3 = 0 ;
12955 PyObject * obj0 = 0 ;
12956 PyObject * obj1 = 0 ;
12957 PyObject * obj2 = 0 ;
12958 char * kwnames[] = {
12959 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12960 };
12961
12962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12963 {
12964 arg1 = wxString_in_helper(obj0);
12965 if (arg1 == NULL) SWIG_fail;
12966 temp1 = true;
12967 }
12968 {
12969 arg2 = wxString_in_helper(obj1);
12970 if (arg2 == NULL) SWIG_fail;
12971 temp2 = true;
12972 }
12973 if (obj2) {
12974 ecode3 = SWIG_AsVal_int(obj2, &val3);
12975 if (!SWIG_IsOK(ecode3)) {
12976 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12977 }
12978 arg3 = static_cast< int >(val3);
12979 }
12980 {
12981 PyThreadState* __tstate = wxPyBeginAllowThreads();
12982 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12983 wxPyEndAllowThreads(__tstate);
12984 if (PyErr_Occurred()) SWIG_fail;
12985 }
12986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12987 {
12988 if (temp1)
12989 delete arg1;
12990 }
12991 {
12992 if (temp2)
12993 delete arg2;
12994 }
12995 return resultobj;
12996 fail:
12997 {
12998 if (temp1)
12999 delete arg1;
13000 }
13001 {
13002 if (temp2)
13003 delete arg2;
13004 }
13005 return NULL;
13006 }
13007
13008
13009 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13010 PyObject *resultobj = 0;
13011 wxInputStream *arg1 = 0 ;
13012 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13013 int arg3 = (int) -1 ;
13014 wxImage *result = 0 ;
13015 wxPyInputStream *temp1 ;
13016 bool created1 ;
13017 long val2 ;
13018 int ecode2 = 0 ;
13019 int val3 ;
13020 int ecode3 = 0 ;
13021 PyObject * obj0 = 0 ;
13022 PyObject * obj1 = 0 ;
13023 PyObject * obj2 = 0 ;
13024 char * kwnames[] = {
13025 (char *) "stream",(char *) "type",(char *) "index", NULL
13026 };
13027
13028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13029 {
13030 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13031 arg1 = temp1->m_wxis;
13032 created1 = false;
13033 } else {
13034 PyErr_Clear(); // clear the failure of the wxPyConvert above
13035 arg1 = wxPyCBInputStream_create(obj0, false);
13036 if (arg1 == NULL) {
13037 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13038 SWIG_fail;
13039 }
13040 created1 = true;
13041 }
13042 }
13043 if (obj1) {
13044 ecode2 = SWIG_AsVal_long(obj1, &val2);
13045 if (!SWIG_IsOK(ecode2)) {
13046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13047 }
13048 arg2 = static_cast< long >(val2);
13049 }
13050 if (obj2) {
13051 ecode3 = SWIG_AsVal_int(obj2, &val3);
13052 if (!SWIG_IsOK(ecode3)) {
13053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13054 }
13055 arg3 = static_cast< int >(val3);
13056 }
13057 {
13058 PyThreadState* __tstate = wxPyBeginAllowThreads();
13059 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13060 wxPyEndAllowThreads(__tstate);
13061 if (PyErr_Occurred()) SWIG_fail;
13062 }
13063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13064 {
13065 if (created1) delete arg1;
13066 }
13067 return resultobj;
13068 fail:
13069 {
13070 if (created1) delete arg1;
13071 }
13072 return NULL;
13073 }
13074
13075
13076 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13077 PyObject *resultobj = 0;
13078 wxInputStream *arg1 = 0 ;
13079 wxString *arg2 = 0 ;
13080 int arg3 = (int) -1 ;
13081 wxImage *result = 0 ;
13082 wxPyInputStream *temp1 ;
13083 bool created1 ;
13084 bool temp2 = false ;
13085 int val3 ;
13086 int ecode3 = 0 ;
13087 PyObject * obj0 = 0 ;
13088 PyObject * obj1 = 0 ;
13089 PyObject * obj2 = 0 ;
13090 char * kwnames[] = {
13091 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13092 };
13093
13094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13095 {
13096 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13097 arg1 = temp1->m_wxis;
13098 created1 = false;
13099 } else {
13100 PyErr_Clear(); // clear the failure of the wxPyConvert above
13101 arg1 = wxPyCBInputStream_create(obj0, false);
13102 if (arg1 == NULL) {
13103 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13104 SWIG_fail;
13105 }
13106 created1 = true;
13107 }
13108 }
13109 {
13110 arg2 = wxString_in_helper(obj1);
13111 if (arg2 == NULL) SWIG_fail;
13112 temp2 = true;
13113 }
13114 if (obj2) {
13115 ecode3 = SWIG_AsVal_int(obj2, &val3);
13116 if (!SWIG_IsOK(ecode3)) {
13117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13118 }
13119 arg3 = static_cast< int >(val3);
13120 }
13121 {
13122 PyThreadState* __tstate = wxPyBeginAllowThreads();
13123 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13124 wxPyEndAllowThreads(__tstate);
13125 if (PyErr_Occurred()) SWIG_fail;
13126 }
13127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13128 {
13129 if (created1) delete arg1;
13130 }
13131 {
13132 if (temp2)
13133 delete arg2;
13134 }
13135 return resultobj;
13136 fail:
13137 {
13138 if (created1) delete arg1;
13139 }
13140 {
13141 if (temp2)
13142 delete arg2;
13143 }
13144 return NULL;
13145 }
13146
13147
13148 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13149 PyObject *resultobj = 0;
13150 int arg1 = (int) 0 ;
13151 int arg2 = (int) 0 ;
13152 bool arg3 = (bool) true ;
13153 wxImage *result = 0 ;
13154 int val1 ;
13155 int ecode1 = 0 ;
13156 int val2 ;
13157 int ecode2 = 0 ;
13158 bool val3 ;
13159 int ecode3 = 0 ;
13160 PyObject * obj0 = 0 ;
13161 PyObject * obj1 = 0 ;
13162 PyObject * obj2 = 0 ;
13163 char * kwnames[] = {
13164 (char *) "width",(char *) "height",(char *) "clear", NULL
13165 };
13166
13167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13168 if (obj0) {
13169 ecode1 = SWIG_AsVal_int(obj0, &val1);
13170 if (!SWIG_IsOK(ecode1)) {
13171 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13172 }
13173 arg1 = static_cast< int >(val1);
13174 }
13175 if (obj1) {
13176 ecode2 = SWIG_AsVal_int(obj1, &val2);
13177 if (!SWIG_IsOK(ecode2)) {
13178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13179 }
13180 arg2 = static_cast< int >(val2);
13181 }
13182 if (obj2) {
13183 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13184 if (!SWIG_IsOK(ecode3)) {
13185 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13186 }
13187 arg3 = static_cast< bool >(val3);
13188 }
13189 {
13190 PyThreadState* __tstate = wxPyBeginAllowThreads();
13191 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13192 wxPyEndAllowThreads(__tstate);
13193 if (PyErr_Occurred()) SWIG_fail;
13194 }
13195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13196 return resultobj;
13197 fail:
13198 return NULL;
13199 }
13200
13201
13202 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13203 PyObject *resultobj = 0;
13204 wxBitmap *arg1 = 0 ;
13205 wxImage *result = 0 ;
13206 void *argp1 = 0 ;
13207 int res1 = 0 ;
13208 PyObject * obj0 = 0 ;
13209 char * kwnames[] = {
13210 (char *) "bitmap", NULL
13211 };
13212
13213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13214 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13215 if (!SWIG_IsOK(res1)) {
13216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13217 }
13218 if (!argp1) {
13219 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13220 }
13221 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13222 {
13223 if (!wxPyCheckForApp()) SWIG_fail;
13224 PyThreadState* __tstate = wxPyBeginAllowThreads();
13225 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13226 wxPyEndAllowThreads(__tstate);
13227 if (PyErr_Occurred()) SWIG_fail;
13228 }
13229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13230 return resultobj;
13231 fail:
13232 return NULL;
13233 }
13234
13235
13236 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13237 PyObject *resultobj = 0;
13238 int arg1 ;
13239 int arg2 ;
13240 buffer arg3 ;
13241 int arg4 ;
13242 wxImage *result = 0 ;
13243 int val1 ;
13244 int ecode1 = 0 ;
13245 int val2 ;
13246 int ecode2 = 0 ;
13247 PyObject * obj0 = 0 ;
13248 PyObject * obj1 = 0 ;
13249 PyObject * obj2 = 0 ;
13250 char * kwnames[] = {
13251 (char *) "width",(char *) "height",(char *) "data", NULL
13252 };
13253
13254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13255 ecode1 = SWIG_AsVal_int(obj0, &val1);
13256 if (!SWIG_IsOK(ecode1)) {
13257 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13258 }
13259 arg1 = static_cast< int >(val1);
13260 ecode2 = SWIG_AsVal_int(obj1, &val2);
13261 if (!SWIG_IsOK(ecode2)) {
13262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13263 }
13264 arg2 = static_cast< int >(val2);
13265 {
13266 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13267 }
13268 {
13269 PyThreadState* __tstate = wxPyBeginAllowThreads();
13270 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13271 wxPyEndAllowThreads(__tstate);
13272 if (PyErr_Occurred()) SWIG_fail;
13273 }
13274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13275 return resultobj;
13276 fail:
13277 return NULL;
13278 }
13279
13280
13281 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13282 PyObject *resultobj = 0;
13283 int arg1 ;
13284 int arg2 ;
13285 buffer arg3 ;
13286 int arg4 ;
13287 buffer arg5 ;
13288 int arg6 ;
13289 wxImage *result = 0 ;
13290 int val1 ;
13291 int ecode1 = 0 ;
13292 int val2 ;
13293 int ecode2 = 0 ;
13294 PyObject * obj0 = 0 ;
13295 PyObject * obj1 = 0 ;
13296 PyObject * obj2 = 0 ;
13297 PyObject * obj3 = 0 ;
13298 char * kwnames[] = {
13299 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13300 };
13301
13302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13303 ecode1 = SWIG_AsVal_int(obj0, &val1);
13304 if (!SWIG_IsOK(ecode1)) {
13305 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13306 }
13307 arg1 = static_cast< int >(val1);
13308 ecode2 = SWIG_AsVal_int(obj1, &val2);
13309 if (!SWIG_IsOK(ecode2)) {
13310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13311 }
13312 arg2 = static_cast< int >(val2);
13313 {
13314 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13315 }
13316 {
13317 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13318 }
13319 {
13320 PyThreadState* __tstate = wxPyBeginAllowThreads();
13321 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13322 wxPyEndAllowThreads(__tstate);
13323 if (PyErr_Occurred()) SWIG_fail;
13324 }
13325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13326 return resultobj;
13327 fail:
13328 return NULL;
13329 }
13330
13331
13332 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13333 PyObject *resultobj = 0;
13334 wxImage *arg1 = (wxImage *) 0 ;
13335 int arg2 ;
13336 int arg3 ;
13337 bool arg4 = (bool) true ;
13338 void *argp1 = 0 ;
13339 int res1 = 0 ;
13340 int val2 ;
13341 int ecode2 = 0 ;
13342 int val3 ;
13343 int ecode3 = 0 ;
13344 bool val4 ;
13345 int ecode4 = 0 ;
13346 PyObject * obj0 = 0 ;
13347 PyObject * obj1 = 0 ;
13348 PyObject * obj2 = 0 ;
13349 PyObject * obj3 = 0 ;
13350 char * kwnames[] = {
13351 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13352 };
13353
13354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13356 if (!SWIG_IsOK(res1)) {
13357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13358 }
13359 arg1 = reinterpret_cast< wxImage * >(argp1);
13360 ecode2 = SWIG_AsVal_int(obj1, &val2);
13361 if (!SWIG_IsOK(ecode2)) {
13362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13363 }
13364 arg2 = static_cast< int >(val2);
13365 ecode3 = SWIG_AsVal_int(obj2, &val3);
13366 if (!SWIG_IsOK(ecode3)) {
13367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13368 }
13369 arg3 = static_cast< int >(val3);
13370 if (obj3) {
13371 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13372 if (!SWIG_IsOK(ecode4)) {
13373 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13374 }
13375 arg4 = static_cast< bool >(val4);
13376 }
13377 {
13378 PyThreadState* __tstate = wxPyBeginAllowThreads();
13379 (arg1)->Create(arg2,arg3,arg4);
13380 wxPyEndAllowThreads(__tstate);
13381 if (PyErr_Occurred()) SWIG_fail;
13382 }
13383 resultobj = SWIG_Py_Void();
13384 return resultobj;
13385 fail:
13386 return NULL;
13387 }
13388
13389
13390 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13391 PyObject *resultobj = 0;
13392 wxImage *arg1 = (wxImage *) 0 ;
13393 void *argp1 = 0 ;
13394 int res1 = 0 ;
13395 PyObject *swig_obj[1] ;
13396
13397 if (!args) SWIG_fail;
13398 swig_obj[0] = args;
13399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13400 if (!SWIG_IsOK(res1)) {
13401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13402 }
13403 arg1 = reinterpret_cast< wxImage * >(argp1);
13404 {
13405 PyThreadState* __tstate = wxPyBeginAllowThreads();
13406 (arg1)->Destroy();
13407 wxPyEndAllowThreads(__tstate);
13408 if (PyErr_Occurred()) SWIG_fail;
13409 }
13410 resultobj = SWIG_Py_Void();
13411 return resultobj;
13412 fail:
13413 return NULL;
13414 }
13415
13416
13417 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13418 PyObject *resultobj = 0;
13419 wxImage *arg1 = (wxImage *) 0 ;
13420 int arg2 ;
13421 int arg3 ;
13422 SwigValueWrapper<wxImage > result;
13423 void *argp1 = 0 ;
13424 int res1 = 0 ;
13425 int val2 ;
13426 int ecode2 = 0 ;
13427 int val3 ;
13428 int ecode3 = 0 ;
13429 PyObject * obj0 = 0 ;
13430 PyObject * obj1 = 0 ;
13431 PyObject * obj2 = 0 ;
13432 char * kwnames[] = {
13433 (char *) "self",(char *) "width",(char *) "height", NULL
13434 };
13435
13436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13438 if (!SWIG_IsOK(res1)) {
13439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13440 }
13441 arg1 = reinterpret_cast< wxImage * >(argp1);
13442 ecode2 = SWIG_AsVal_int(obj1, &val2);
13443 if (!SWIG_IsOK(ecode2)) {
13444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13445 }
13446 arg2 = static_cast< int >(val2);
13447 ecode3 = SWIG_AsVal_int(obj2, &val3);
13448 if (!SWIG_IsOK(ecode3)) {
13449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13450 }
13451 arg3 = static_cast< int >(val3);
13452 {
13453 PyThreadState* __tstate = wxPyBeginAllowThreads();
13454 result = (arg1)->Scale(arg2,arg3);
13455 wxPyEndAllowThreads(__tstate);
13456 if (PyErr_Occurred()) SWIG_fail;
13457 }
13458 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13459 return resultobj;
13460 fail:
13461 return NULL;
13462 }
13463
13464
13465 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13466 PyObject *resultobj = 0;
13467 wxImage *arg1 = (wxImage *) 0 ;
13468 int arg2 ;
13469 int arg3 ;
13470 SwigValueWrapper<wxImage > result;
13471 void *argp1 = 0 ;
13472 int res1 = 0 ;
13473 int val2 ;
13474 int ecode2 = 0 ;
13475 int val3 ;
13476 int ecode3 = 0 ;
13477 PyObject * obj0 = 0 ;
13478 PyObject * obj1 = 0 ;
13479 PyObject * obj2 = 0 ;
13480 char * kwnames[] = {
13481 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13482 };
13483
13484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13486 if (!SWIG_IsOK(res1)) {
13487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13488 }
13489 arg1 = reinterpret_cast< wxImage * >(argp1);
13490 ecode2 = SWIG_AsVal_int(obj1, &val2);
13491 if (!SWIG_IsOK(ecode2)) {
13492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13493 }
13494 arg2 = static_cast< int >(val2);
13495 ecode3 = SWIG_AsVal_int(obj2, &val3);
13496 if (!SWIG_IsOK(ecode3)) {
13497 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13498 }
13499 arg3 = static_cast< int >(val3);
13500 {
13501 PyThreadState* __tstate = wxPyBeginAllowThreads();
13502 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13503 wxPyEndAllowThreads(__tstate);
13504 if (PyErr_Occurred()) SWIG_fail;
13505 }
13506 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13507 return resultobj;
13508 fail:
13509 return NULL;
13510 }
13511
13512
13513 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13514 PyObject *resultobj = 0;
13515 wxImage *arg1 = (wxImage *) 0 ;
13516 int arg2 ;
13517 int arg3 ;
13518 wxImage *result = 0 ;
13519 void *argp1 = 0 ;
13520 int res1 = 0 ;
13521 int val2 ;
13522 int ecode2 = 0 ;
13523 int val3 ;
13524 int ecode3 = 0 ;
13525 PyObject * obj0 = 0 ;
13526 PyObject * obj1 = 0 ;
13527 PyObject * obj2 = 0 ;
13528 char * kwnames[] = {
13529 (char *) "self",(char *) "width",(char *) "height", NULL
13530 };
13531
13532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13534 if (!SWIG_IsOK(res1)) {
13535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13536 }
13537 arg1 = reinterpret_cast< wxImage * >(argp1);
13538 ecode2 = SWIG_AsVal_int(obj1, &val2);
13539 if (!SWIG_IsOK(ecode2)) {
13540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13541 }
13542 arg2 = static_cast< int >(val2);
13543 ecode3 = SWIG_AsVal_int(obj2, &val3);
13544 if (!SWIG_IsOK(ecode3)) {
13545 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13546 }
13547 arg3 = static_cast< int >(val3);
13548 {
13549 PyThreadState* __tstate = wxPyBeginAllowThreads();
13550 {
13551 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13552 result = (wxImage *) &_result_ref;
13553 }
13554 wxPyEndAllowThreads(__tstate);
13555 if (PyErr_Occurred()) SWIG_fail;
13556 }
13557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13558 return resultobj;
13559 fail:
13560 return NULL;
13561 }
13562
13563
13564 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13565 PyObject *resultobj = 0;
13566 wxImage *arg1 = (wxImage *) 0 ;
13567 wxSize *arg2 = 0 ;
13568 wxPoint *arg3 = 0 ;
13569 int arg4 = (int) -1 ;
13570 int arg5 = (int) -1 ;
13571 int arg6 = (int) -1 ;
13572 wxImage *result = 0 ;
13573 void *argp1 = 0 ;
13574 int res1 = 0 ;
13575 wxSize temp2 ;
13576 wxPoint temp3 ;
13577 int val4 ;
13578 int ecode4 = 0 ;
13579 int val5 ;
13580 int ecode5 = 0 ;
13581 int val6 ;
13582 int ecode6 = 0 ;
13583 PyObject * obj0 = 0 ;
13584 PyObject * obj1 = 0 ;
13585 PyObject * obj2 = 0 ;
13586 PyObject * obj3 = 0 ;
13587 PyObject * obj4 = 0 ;
13588 PyObject * obj5 = 0 ;
13589 char * kwnames[] = {
13590 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13591 };
13592
13593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13595 if (!SWIG_IsOK(res1)) {
13596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13597 }
13598 arg1 = reinterpret_cast< wxImage * >(argp1);
13599 {
13600 arg2 = &temp2;
13601 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13602 }
13603 {
13604 arg3 = &temp3;
13605 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13606 }
13607 if (obj3) {
13608 ecode4 = SWIG_AsVal_int(obj3, &val4);
13609 if (!SWIG_IsOK(ecode4)) {
13610 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13611 }
13612 arg4 = static_cast< int >(val4);
13613 }
13614 if (obj4) {
13615 ecode5 = SWIG_AsVal_int(obj4, &val5);
13616 if (!SWIG_IsOK(ecode5)) {
13617 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13618 }
13619 arg5 = static_cast< int >(val5);
13620 }
13621 if (obj5) {
13622 ecode6 = SWIG_AsVal_int(obj5, &val6);
13623 if (!SWIG_IsOK(ecode6)) {
13624 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13625 }
13626 arg6 = static_cast< int >(val6);
13627 }
13628 {
13629 PyThreadState* __tstate = wxPyBeginAllowThreads();
13630 {
13631 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13632 result = (wxImage *) &_result_ref;
13633 }
13634 wxPyEndAllowThreads(__tstate);
13635 if (PyErr_Occurred()) SWIG_fail;
13636 }
13637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13638 return resultobj;
13639 fail:
13640 return NULL;
13641 }
13642
13643
13644 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13645 PyObject *resultobj = 0;
13646 wxImage *arg1 = (wxImage *) 0 ;
13647 int arg2 ;
13648 int arg3 ;
13649 byte arg4 ;
13650 byte arg5 ;
13651 byte arg6 ;
13652 void *argp1 = 0 ;
13653 int res1 = 0 ;
13654 int val2 ;
13655 int ecode2 = 0 ;
13656 int val3 ;
13657 int ecode3 = 0 ;
13658 unsigned char val4 ;
13659 int ecode4 = 0 ;
13660 unsigned char val5 ;
13661 int ecode5 = 0 ;
13662 unsigned char val6 ;
13663 int ecode6 = 0 ;
13664 PyObject * obj0 = 0 ;
13665 PyObject * obj1 = 0 ;
13666 PyObject * obj2 = 0 ;
13667 PyObject * obj3 = 0 ;
13668 PyObject * obj4 = 0 ;
13669 PyObject * obj5 = 0 ;
13670 char * kwnames[] = {
13671 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13672 };
13673
13674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13676 if (!SWIG_IsOK(res1)) {
13677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13678 }
13679 arg1 = reinterpret_cast< wxImage * >(argp1);
13680 ecode2 = SWIG_AsVal_int(obj1, &val2);
13681 if (!SWIG_IsOK(ecode2)) {
13682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13683 }
13684 arg2 = static_cast< int >(val2);
13685 ecode3 = SWIG_AsVal_int(obj2, &val3);
13686 if (!SWIG_IsOK(ecode3)) {
13687 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13688 }
13689 arg3 = static_cast< int >(val3);
13690 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13691 if (!SWIG_IsOK(ecode4)) {
13692 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13693 }
13694 arg4 = static_cast< byte >(val4);
13695 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13696 if (!SWIG_IsOK(ecode5)) {
13697 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13698 }
13699 arg5 = static_cast< byte >(val5);
13700 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13701 if (!SWIG_IsOK(ecode6)) {
13702 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13703 }
13704 arg6 = static_cast< byte >(val6);
13705 {
13706 PyThreadState* __tstate = wxPyBeginAllowThreads();
13707 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13708 wxPyEndAllowThreads(__tstate);
13709 if (PyErr_Occurred()) SWIG_fail;
13710 }
13711 resultobj = SWIG_Py_Void();
13712 return resultobj;
13713 fail:
13714 return NULL;
13715 }
13716
13717
13718 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13719 PyObject *resultobj = 0;
13720 wxImage *arg1 = (wxImage *) 0 ;
13721 wxRect *arg2 = 0 ;
13722 byte arg3 ;
13723 byte arg4 ;
13724 byte arg5 ;
13725 void *argp1 = 0 ;
13726 int res1 = 0 ;
13727 wxRect temp2 ;
13728 unsigned char val3 ;
13729 int ecode3 = 0 ;
13730 unsigned char val4 ;
13731 int ecode4 = 0 ;
13732 unsigned char val5 ;
13733 int ecode5 = 0 ;
13734 PyObject * obj0 = 0 ;
13735 PyObject * obj1 = 0 ;
13736 PyObject * obj2 = 0 ;
13737 PyObject * obj3 = 0 ;
13738 PyObject * obj4 = 0 ;
13739 char * kwnames[] = {
13740 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13741 };
13742
13743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13745 if (!SWIG_IsOK(res1)) {
13746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13747 }
13748 arg1 = reinterpret_cast< wxImage * >(argp1);
13749 {
13750 arg2 = &temp2;
13751 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13752 }
13753 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13754 if (!SWIG_IsOK(ecode3)) {
13755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13756 }
13757 arg3 = static_cast< byte >(val3);
13758 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13759 if (!SWIG_IsOK(ecode4)) {
13760 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13761 }
13762 arg4 = static_cast< byte >(val4);
13763 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13764 if (!SWIG_IsOK(ecode5)) {
13765 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13766 }
13767 arg5 = static_cast< byte >(val5);
13768 {
13769 PyThreadState* __tstate = wxPyBeginAllowThreads();
13770 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13771 wxPyEndAllowThreads(__tstate);
13772 if (PyErr_Occurred()) SWIG_fail;
13773 }
13774 resultobj = SWIG_Py_Void();
13775 return resultobj;
13776 fail:
13777 return NULL;
13778 }
13779
13780
13781 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13782 PyObject *resultobj = 0;
13783 wxImage *arg1 = (wxImage *) 0 ;
13784 int arg2 ;
13785 int arg3 ;
13786 byte result;
13787 void *argp1 = 0 ;
13788 int res1 = 0 ;
13789 int val2 ;
13790 int ecode2 = 0 ;
13791 int val3 ;
13792 int ecode3 = 0 ;
13793 PyObject * obj0 = 0 ;
13794 PyObject * obj1 = 0 ;
13795 PyObject * obj2 = 0 ;
13796 char * kwnames[] = {
13797 (char *) "self",(char *) "x",(char *) "y", NULL
13798 };
13799
13800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13802 if (!SWIG_IsOK(res1)) {
13803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13804 }
13805 arg1 = reinterpret_cast< wxImage * >(argp1);
13806 ecode2 = SWIG_AsVal_int(obj1, &val2);
13807 if (!SWIG_IsOK(ecode2)) {
13808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13809 }
13810 arg2 = static_cast< int >(val2);
13811 ecode3 = SWIG_AsVal_int(obj2, &val3);
13812 if (!SWIG_IsOK(ecode3)) {
13813 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13814 }
13815 arg3 = static_cast< int >(val3);
13816 {
13817 PyThreadState* __tstate = wxPyBeginAllowThreads();
13818 result = (byte)(arg1)->GetRed(arg2,arg3);
13819 wxPyEndAllowThreads(__tstate);
13820 if (PyErr_Occurred()) SWIG_fail;
13821 }
13822 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13823 return resultobj;
13824 fail:
13825 return NULL;
13826 }
13827
13828
13829 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13830 PyObject *resultobj = 0;
13831 wxImage *arg1 = (wxImage *) 0 ;
13832 int arg2 ;
13833 int arg3 ;
13834 byte result;
13835 void *argp1 = 0 ;
13836 int res1 = 0 ;
13837 int val2 ;
13838 int ecode2 = 0 ;
13839 int val3 ;
13840 int ecode3 = 0 ;
13841 PyObject * obj0 = 0 ;
13842 PyObject * obj1 = 0 ;
13843 PyObject * obj2 = 0 ;
13844 char * kwnames[] = {
13845 (char *) "self",(char *) "x",(char *) "y", NULL
13846 };
13847
13848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13850 if (!SWIG_IsOK(res1)) {
13851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13852 }
13853 arg1 = reinterpret_cast< wxImage * >(argp1);
13854 ecode2 = SWIG_AsVal_int(obj1, &val2);
13855 if (!SWIG_IsOK(ecode2)) {
13856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13857 }
13858 arg2 = static_cast< int >(val2);
13859 ecode3 = SWIG_AsVal_int(obj2, &val3);
13860 if (!SWIG_IsOK(ecode3)) {
13861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13862 }
13863 arg3 = static_cast< int >(val3);
13864 {
13865 PyThreadState* __tstate = wxPyBeginAllowThreads();
13866 result = (byte)(arg1)->GetGreen(arg2,arg3);
13867 wxPyEndAllowThreads(__tstate);
13868 if (PyErr_Occurred()) SWIG_fail;
13869 }
13870 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13871 return resultobj;
13872 fail:
13873 return NULL;
13874 }
13875
13876
13877 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13878 PyObject *resultobj = 0;
13879 wxImage *arg1 = (wxImage *) 0 ;
13880 int arg2 ;
13881 int arg3 ;
13882 byte result;
13883 void *argp1 = 0 ;
13884 int res1 = 0 ;
13885 int val2 ;
13886 int ecode2 = 0 ;
13887 int val3 ;
13888 int ecode3 = 0 ;
13889 PyObject * obj0 = 0 ;
13890 PyObject * obj1 = 0 ;
13891 PyObject * obj2 = 0 ;
13892 char * kwnames[] = {
13893 (char *) "self",(char *) "x",(char *) "y", NULL
13894 };
13895
13896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13898 if (!SWIG_IsOK(res1)) {
13899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13900 }
13901 arg1 = reinterpret_cast< wxImage * >(argp1);
13902 ecode2 = SWIG_AsVal_int(obj1, &val2);
13903 if (!SWIG_IsOK(ecode2)) {
13904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13905 }
13906 arg2 = static_cast< int >(val2);
13907 ecode3 = SWIG_AsVal_int(obj2, &val3);
13908 if (!SWIG_IsOK(ecode3)) {
13909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13910 }
13911 arg3 = static_cast< int >(val3);
13912 {
13913 PyThreadState* __tstate = wxPyBeginAllowThreads();
13914 result = (byte)(arg1)->GetBlue(arg2,arg3);
13915 wxPyEndAllowThreads(__tstate);
13916 if (PyErr_Occurred()) SWIG_fail;
13917 }
13918 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13919 return resultobj;
13920 fail:
13921 return NULL;
13922 }
13923
13924
13925 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13926 PyObject *resultobj = 0;
13927 wxImage *arg1 = (wxImage *) 0 ;
13928 int arg2 ;
13929 int arg3 ;
13930 byte arg4 ;
13931 void *argp1 = 0 ;
13932 int res1 = 0 ;
13933 int val2 ;
13934 int ecode2 = 0 ;
13935 int val3 ;
13936 int ecode3 = 0 ;
13937 unsigned char val4 ;
13938 int ecode4 = 0 ;
13939 PyObject * obj0 = 0 ;
13940 PyObject * obj1 = 0 ;
13941 PyObject * obj2 = 0 ;
13942 PyObject * obj3 = 0 ;
13943 char * kwnames[] = {
13944 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13945 };
13946
13947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13949 if (!SWIG_IsOK(res1)) {
13950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13951 }
13952 arg1 = reinterpret_cast< wxImage * >(argp1);
13953 ecode2 = SWIG_AsVal_int(obj1, &val2);
13954 if (!SWIG_IsOK(ecode2)) {
13955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13956 }
13957 arg2 = static_cast< int >(val2);
13958 ecode3 = SWIG_AsVal_int(obj2, &val3);
13959 if (!SWIG_IsOK(ecode3)) {
13960 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13961 }
13962 arg3 = static_cast< int >(val3);
13963 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13964 if (!SWIG_IsOK(ecode4)) {
13965 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13966 }
13967 arg4 = static_cast< byte >(val4);
13968 {
13969 PyThreadState* __tstate = wxPyBeginAllowThreads();
13970 (arg1)->SetAlpha(arg2,arg3,arg4);
13971 wxPyEndAllowThreads(__tstate);
13972 if (PyErr_Occurred()) SWIG_fail;
13973 }
13974 resultobj = SWIG_Py_Void();
13975 return resultobj;
13976 fail:
13977 return NULL;
13978 }
13979
13980
13981 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13982 PyObject *resultobj = 0;
13983 wxImage *arg1 = (wxImage *) 0 ;
13984 int arg2 ;
13985 int arg3 ;
13986 byte result;
13987 void *argp1 = 0 ;
13988 int res1 = 0 ;
13989 int val2 ;
13990 int ecode2 = 0 ;
13991 int val3 ;
13992 int ecode3 = 0 ;
13993 PyObject * obj0 = 0 ;
13994 PyObject * obj1 = 0 ;
13995 PyObject * obj2 = 0 ;
13996 char * kwnames[] = {
13997 (char *) "self",(char *) "x",(char *) "y", NULL
13998 };
13999
14000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14002 if (!SWIG_IsOK(res1)) {
14003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14004 }
14005 arg1 = reinterpret_cast< wxImage * >(argp1);
14006 ecode2 = SWIG_AsVal_int(obj1, &val2);
14007 if (!SWIG_IsOK(ecode2)) {
14008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14009 }
14010 arg2 = static_cast< int >(val2);
14011 ecode3 = SWIG_AsVal_int(obj2, &val3);
14012 if (!SWIG_IsOK(ecode3)) {
14013 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14014 }
14015 arg3 = static_cast< int >(val3);
14016 {
14017 PyThreadState* __tstate = wxPyBeginAllowThreads();
14018 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14019 wxPyEndAllowThreads(__tstate);
14020 if (PyErr_Occurred()) SWIG_fail;
14021 }
14022 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14023 return resultobj;
14024 fail:
14025 return NULL;
14026 }
14027
14028
14029 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14030 PyObject *resultobj = 0;
14031 wxImage *arg1 = (wxImage *) 0 ;
14032 bool result;
14033 void *argp1 = 0 ;
14034 int res1 = 0 ;
14035 PyObject *swig_obj[1] ;
14036
14037 if (!args) SWIG_fail;
14038 swig_obj[0] = args;
14039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14040 if (!SWIG_IsOK(res1)) {
14041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14042 }
14043 arg1 = reinterpret_cast< wxImage * >(argp1);
14044 {
14045 PyThreadState* __tstate = wxPyBeginAllowThreads();
14046 result = (bool)(arg1)->HasAlpha();
14047 wxPyEndAllowThreads(__tstate);
14048 if (PyErr_Occurred()) SWIG_fail;
14049 }
14050 {
14051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14052 }
14053 return resultobj;
14054 fail:
14055 return NULL;
14056 }
14057
14058
14059 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14060 PyObject *resultobj = 0;
14061 wxImage *arg1 = (wxImage *) 0 ;
14062 void *argp1 = 0 ;
14063 int res1 = 0 ;
14064 PyObject *swig_obj[1] ;
14065
14066 if (!args) SWIG_fail;
14067 swig_obj[0] = args;
14068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14069 if (!SWIG_IsOK(res1)) {
14070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14071 }
14072 arg1 = reinterpret_cast< wxImage * >(argp1);
14073 {
14074 PyThreadState* __tstate = wxPyBeginAllowThreads();
14075 (arg1)->InitAlpha();
14076 wxPyEndAllowThreads(__tstate);
14077 if (PyErr_Occurred()) SWIG_fail;
14078 }
14079 resultobj = SWIG_Py_Void();
14080 return resultobj;
14081 fail:
14082 return NULL;
14083 }
14084
14085
14086 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14087 PyObject *resultobj = 0;
14088 wxImage *arg1 = (wxImage *) 0 ;
14089 int arg2 ;
14090 int arg3 ;
14091 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14092 bool result;
14093 void *argp1 = 0 ;
14094 int res1 = 0 ;
14095 int val2 ;
14096 int ecode2 = 0 ;
14097 int val3 ;
14098 int ecode3 = 0 ;
14099 unsigned char val4 ;
14100 int ecode4 = 0 ;
14101 PyObject * obj0 = 0 ;
14102 PyObject * obj1 = 0 ;
14103 PyObject * obj2 = 0 ;
14104 PyObject * obj3 = 0 ;
14105 char * kwnames[] = {
14106 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14107 };
14108
14109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14111 if (!SWIG_IsOK(res1)) {
14112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14113 }
14114 arg1 = reinterpret_cast< wxImage * >(argp1);
14115 ecode2 = SWIG_AsVal_int(obj1, &val2);
14116 if (!SWIG_IsOK(ecode2)) {
14117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14118 }
14119 arg2 = static_cast< int >(val2);
14120 ecode3 = SWIG_AsVal_int(obj2, &val3);
14121 if (!SWIG_IsOK(ecode3)) {
14122 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14123 }
14124 arg3 = static_cast< int >(val3);
14125 if (obj3) {
14126 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14127 if (!SWIG_IsOK(ecode4)) {
14128 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14129 }
14130 arg4 = static_cast< byte >(val4);
14131 }
14132 {
14133 PyThreadState* __tstate = wxPyBeginAllowThreads();
14134 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14135 wxPyEndAllowThreads(__tstate);
14136 if (PyErr_Occurred()) SWIG_fail;
14137 }
14138 {
14139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14140 }
14141 return resultobj;
14142 fail:
14143 return NULL;
14144 }
14145
14146
14147 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14148 PyObject *resultobj = 0;
14149 wxImage *arg1 = (wxImage *) 0 ;
14150 byte *arg2 = (byte *) 0 ;
14151 byte *arg3 = (byte *) 0 ;
14152 byte *arg4 = (byte *) 0 ;
14153 byte arg5 = (byte) 0 ;
14154 byte arg6 = (byte) 0 ;
14155 byte arg7 = (byte) 0 ;
14156 bool result;
14157 void *argp1 = 0 ;
14158 int res1 = 0 ;
14159 byte temp2 ;
14160 int res2 = SWIG_TMPOBJ ;
14161 byte temp3 ;
14162 int res3 = SWIG_TMPOBJ ;
14163 byte temp4 ;
14164 int res4 = SWIG_TMPOBJ ;
14165 unsigned char val5 ;
14166 int ecode5 = 0 ;
14167 unsigned char val6 ;
14168 int ecode6 = 0 ;
14169 unsigned char val7 ;
14170 int ecode7 = 0 ;
14171 PyObject * obj0 = 0 ;
14172 PyObject * obj1 = 0 ;
14173 PyObject * obj2 = 0 ;
14174 PyObject * obj3 = 0 ;
14175 char * kwnames[] = {
14176 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14177 };
14178
14179 arg2 = &temp2;
14180 arg3 = &temp3;
14181 arg4 = &temp4;
14182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14184 if (!SWIG_IsOK(res1)) {
14185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14186 }
14187 arg1 = reinterpret_cast< wxImage * >(argp1);
14188 if (obj1) {
14189 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14190 if (!SWIG_IsOK(ecode5)) {
14191 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14192 }
14193 arg5 = static_cast< byte >(val5);
14194 }
14195 if (obj2) {
14196 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14197 if (!SWIG_IsOK(ecode6)) {
14198 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14199 }
14200 arg6 = static_cast< byte >(val6);
14201 }
14202 if (obj3) {
14203 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14204 if (!SWIG_IsOK(ecode7)) {
14205 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14206 }
14207 arg7 = static_cast< byte >(val7);
14208 }
14209 {
14210 PyThreadState* __tstate = wxPyBeginAllowThreads();
14211 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14212 wxPyEndAllowThreads(__tstate);
14213 if (PyErr_Occurred()) SWIG_fail;
14214 }
14215 {
14216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14217 }
14218 if (SWIG_IsTmpObj(res2)) {
14219 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14220 } else {
14221 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14222 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14223 }
14224 if (SWIG_IsTmpObj(res3)) {
14225 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14226 } else {
14227 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14228 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14229 }
14230 if (SWIG_IsTmpObj(res4)) {
14231 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14232 } else {
14233 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14234 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14235 }
14236 return resultobj;
14237 fail:
14238 return NULL;
14239 }
14240
14241
14242 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14243 PyObject *resultobj = 0;
14244 wxImage *arg1 = (wxImage *) 0 ;
14245 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14246 bool result;
14247 void *argp1 = 0 ;
14248 int res1 = 0 ;
14249 unsigned char val2 ;
14250 int ecode2 = 0 ;
14251 PyObject * obj0 = 0 ;
14252 PyObject * obj1 = 0 ;
14253 char * kwnames[] = {
14254 (char *) "self",(char *) "threshold", NULL
14255 };
14256
14257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14259 if (!SWIG_IsOK(res1)) {
14260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14261 }
14262 arg1 = reinterpret_cast< wxImage * >(argp1);
14263 if (obj1) {
14264 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14265 if (!SWIG_IsOK(ecode2)) {
14266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14267 }
14268 arg2 = static_cast< byte >(val2);
14269 }
14270 {
14271 PyThreadState* __tstate = wxPyBeginAllowThreads();
14272 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14273 wxPyEndAllowThreads(__tstate);
14274 if (PyErr_Occurred()) SWIG_fail;
14275 }
14276 {
14277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14278 }
14279 return resultobj;
14280 fail:
14281 return NULL;
14282 }
14283
14284
14285 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14286 PyObject *resultobj = 0;
14287 wxImage *arg1 = (wxImage *) 0 ;
14288 byte arg2 ;
14289 byte arg3 ;
14290 byte arg4 ;
14291 bool result;
14292 void *argp1 = 0 ;
14293 int res1 = 0 ;
14294 unsigned char val2 ;
14295 int ecode2 = 0 ;
14296 unsigned char val3 ;
14297 int ecode3 = 0 ;
14298 unsigned char val4 ;
14299 int ecode4 = 0 ;
14300 PyObject * obj0 = 0 ;
14301 PyObject * obj1 = 0 ;
14302 PyObject * obj2 = 0 ;
14303 PyObject * obj3 = 0 ;
14304 char * kwnames[] = {
14305 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14306 };
14307
14308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14310 if (!SWIG_IsOK(res1)) {
14311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14312 }
14313 arg1 = reinterpret_cast< wxImage * >(argp1);
14314 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14315 if (!SWIG_IsOK(ecode2)) {
14316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14317 }
14318 arg2 = static_cast< byte >(val2);
14319 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14320 if (!SWIG_IsOK(ecode3)) {
14321 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14322 }
14323 arg3 = static_cast< byte >(val3);
14324 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14325 if (!SWIG_IsOK(ecode4)) {
14326 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14327 }
14328 arg4 = static_cast< byte >(val4);
14329 {
14330 PyThreadState* __tstate = wxPyBeginAllowThreads();
14331 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14332 wxPyEndAllowThreads(__tstate);
14333 if (PyErr_Occurred()) SWIG_fail;
14334 }
14335 {
14336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14337 }
14338 return resultobj;
14339 fail:
14340 return NULL;
14341 }
14342
14343
14344 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14345 PyObject *resultobj = 0;
14346 wxImage *arg1 = (wxImage *) 0 ;
14347 wxImage *arg2 = 0 ;
14348 byte arg3 ;
14349 byte arg4 ;
14350 byte arg5 ;
14351 bool result;
14352 void *argp1 = 0 ;
14353 int res1 = 0 ;
14354 void *argp2 = 0 ;
14355 int res2 = 0 ;
14356 unsigned char val3 ;
14357 int ecode3 = 0 ;
14358 unsigned char val4 ;
14359 int ecode4 = 0 ;
14360 unsigned char val5 ;
14361 int ecode5 = 0 ;
14362 PyObject * obj0 = 0 ;
14363 PyObject * obj1 = 0 ;
14364 PyObject * obj2 = 0 ;
14365 PyObject * obj3 = 0 ;
14366 PyObject * obj4 = 0 ;
14367 char * kwnames[] = {
14368 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14369 };
14370
14371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14373 if (!SWIG_IsOK(res1)) {
14374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14375 }
14376 arg1 = reinterpret_cast< wxImage * >(argp1);
14377 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14378 if (!SWIG_IsOK(res2)) {
14379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14380 }
14381 if (!argp2) {
14382 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14383 }
14384 arg2 = reinterpret_cast< wxImage * >(argp2);
14385 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14386 if (!SWIG_IsOK(ecode3)) {
14387 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14388 }
14389 arg3 = static_cast< byte >(val3);
14390 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14391 if (!SWIG_IsOK(ecode4)) {
14392 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14393 }
14394 arg4 = static_cast< byte >(val4);
14395 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14396 if (!SWIG_IsOK(ecode5)) {
14397 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14398 }
14399 arg5 = static_cast< byte >(val5);
14400 {
14401 PyThreadState* __tstate = wxPyBeginAllowThreads();
14402 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14403 wxPyEndAllowThreads(__tstate);
14404 if (PyErr_Occurred()) SWIG_fail;
14405 }
14406 {
14407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14408 }
14409 return resultobj;
14410 fail:
14411 return NULL;
14412 }
14413
14414
14415 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14416 PyObject *resultobj = 0;
14417 wxString *arg1 = 0 ;
14418 bool result;
14419 bool temp1 = false ;
14420 PyObject * obj0 = 0 ;
14421 char * kwnames[] = {
14422 (char *) "filename", NULL
14423 };
14424
14425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14426 {
14427 arg1 = wxString_in_helper(obj0);
14428 if (arg1 == NULL) SWIG_fail;
14429 temp1 = true;
14430 }
14431 {
14432 PyThreadState* __tstate = wxPyBeginAllowThreads();
14433 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14434 wxPyEndAllowThreads(__tstate);
14435 if (PyErr_Occurred()) SWIG_fail;
14436 }
14437 {
14438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14439 }
14440 {
14441 if (temp1)
14442 delete arg1;
14443 }
14444 return resultobj;
14445 fail:
14446 {
14447 if (temp1)
14448 delete arg1;
14449 }
14450 return NULL;
14451 }
14452
14453
14454 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14455 PyObject *resultobj = 0;
14456 wxString *arg1 = 0 ;
14457 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14458 int result;
14459 bool temp1 = false ;
14460 long val2 ;
14461 int ecode2 = 0 ;
14462 PyObject * obj0 = 0 ;
14463 PyObject * obj1 = 0 ;
14464 char * kwnames[] = {
14465 (char *) "filename",(char *) "type", NULL
14466 };
14467
14468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14469 {
14470 arg1 = wxString_in_helper(obj0);
14471 if (arg1 == NULL) SWIG_fail;
14472 temp1 = true;
14473 }
14474 if (obj1) {
14475 ecode2 = SWIG_AsVal_long(obj1, &val2);
14476 if (!SWIG_IsOK(ecode2)) {
14477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14478 }
14479 arg2 = static_cast< long >(val2);
14480 }
14481 {
14482 PyThreadState* __tstate = wxPyBeginAllowThreads();
14483 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14484 wxPyEndAllowThreads(__tstate);
14485 if (PyErr_Occurred()) SWIG_fail;
14486 }
14487 resultobj = SWIG_From_int(static_cast< int >(result));
14488 {
14489 if (temp1)
14490 delete arg1;
14491 }
14492 return resultobj;
14493 fail:
14494 {
14495 if (temp1)
14496 delete arg1;
14497 }
14498 return NULL;
14499 }
14500
14501
14502 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14503 PyObject *resultobj = 0;
14504 wxImage *arg1 = (wxImage *) 0 ;
14505 wxString *arg2 = 0 ;
14506 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14507 int arg4 = (int) -1 ;
14508 bool result;
14509 void *argp1 = 0 ;
14510 int res1 = 0 ;
14511 bool temp2 = false ;
14512 long val3 ;
14513 int ecode3 = 0 ;
14514 int val4 ;
14515 int ecode4 = 0 ;
14516 PyObject * obj0 = 0 ;
14517 PyObject * obj1 = 0 ;
14518 PyObject * obj2 = 0 ;
14519 PyObject * obj3 = 0 ;
14520 char * kwnames[] = {
14521 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14522 };
14523
14524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14526 if (!SWIG_IsOK(res1)) {
14527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14528 }
14529 arg1 = reinterpret_cast< wxImage * >(argp1);
14530 {
14531 arg2 = wxString_in_helper(obj1);
14532 if (arg2 == NULL) SWIG_fail;
14533 temp2 = true;
14534 }
14535 if (obj2) {
14536 ecode3 = SWIG_AsVal_long(obj2, &val3);
14537 if (!SWIG_IsOK(ecode3)) {
14538 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14539 }
14540 arg3 = static_cast< long >(val3);
14541 }
14542 if (obj3) {
14543 ecode4 = SWIG_AsVal_int(obj3, &val4);
14544 if (!SWIG_IsOK(ecode4)) {
14545 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14546 }
14547 arg4 = static_cast< int >(val4);
14548 }
14549 {
14550 PyThreadState* __tstate = wxPyBeginAllowThreads();
14551 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14552 wxPyEndAllowThreads(__tstate);
14553 if (PyErr_Occurred()) SWIG_fail;
14554 }
14555 {
14556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14557 }
14558 {
14559 if (temp2)
14560 delete arg2;
14561 }
14562 return resultobj;
14563 fail:
14564 {
14565 if (temp2)
14566 delete arg2;
14567 }
14568 return NULL;
14569 }
14570
14571
14572 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14573 PyObject *resultobj = 0;
14574 wxImage *arg1 = (wxImage *) 0 ;
14575 wxString *arg2 = 0 ;
14576 wxString *arg3 = 0 ;
14577 int arg4 = (int) -1 ;
14578 bool result;
14579 void *argp1 = 0 ;
14580 int res1 = 0 ;
14581 bool temp2 = false ;
14582 bool temp3 = false ;
14583 int val4 ;
14584 int ecode4 = 0 ;
14585 PyObject * obj0 = 0 ;
14586 PyObject * obj1 = 0 ;
14587 PyObject * obj2 = 0 ;
14588 PyObject * obj3 = 0 ;
14589 char * kwnames[] = {
14590 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14591 };
14592
14593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14595 if (!SWIG_IsOK(res1)) {
14596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14597 }
14598 arg1 = reinterpret_cast< wxImage * >(argp1);
14599 {
14600 arg2 = wxString_in_helper(obj1);
14601 if (arg2 == NULL) SWIG_fail;
14602 temp2 = true;
14603 }
14604 {
14605 arg3 = wxString_in_helper(obj2);
14606 if (arg3 == NULL) SWIG_fail;
14607 temp3 = true;
14608 }
14609 if (obj3) {
14610 ecode4 = SWIG_AsVal_int(obj3, &val4);
14611 if (!SWIG_IsOK(ecode4)) {
14612 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14613 }
14614 arg4 = static_cast< int >(val4);
14615 }
14616 {
14617 PyThreadState* __tstate = wxPyBeginAllowThreads();
14618 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14619 wxPyEndAllowThreads(__tstate);
14620 if (PyErr_Occurred()) SWIG_fail;
14621 }
14622 {
14623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14624 }
14625 {
14626 if (temp2)
14627 delete arg2;
14628 }
14629 {
14630 if (temp3)
14631 delete arg3;
14632 }
14633 return resultobj;
14634 fail:
14635 {
14636 if (temp2)
14637 delete arg2;
14638 }
14639 {
14640 if (temp3)
14641 delete arg3;
14642 }
14643 return NULL;
14644 }
14645
14646
14647 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14648 PyObject *resultobj = 0;
14649 wxImage *arg1 = (wxImage *) 0 ;
14650 wxString *arg2 = 0 ;
14651 int arg3 ;
14652 bool result;
14653 void *argp1 = 0 ;
14654 int res1 = 0 ;
14655 bool temp2 = false ;
14656 int val3 ;
14657 int ecode3 = 0 ;
14658 PyObject * obj0 = 0 ;
14659 PyObject * obj1 = 0 ;
14660 PyObject * obj2 = 0 ;
14661 char * kwnames[] = {
14662 (char *) "self",(char *) "name",(char *) "type", NULL
14663 };
14664
14665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14667 if (!SWIG_IsOK(res1)) {
14668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14669 }
14670 arg1 = reinterpret_cast< wxImage * >(argp1);
14671 {
14672 arg2 = wxString_in_helper(obj1);
14673 if (arg2 == NULL) SWIG_fail;
14674 temp2 = true;
14675 }
14676 ecode3 = SWIG_AsVal_int(obj2, &val3);
14677 if (!SWIG_IsOK(ecode3)) {
14678 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14679 }
14680 arg3 = static_cast< int >(val3);
14681 {
14682 PyThreadState* __tstate = wxPyBeginAllowThreads();
14683 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14684 wxPyEndAllowThreads(__tstate);
14685 if (PyErr_Occurred()) SWIG_fail;
14686 }
14687 {
14688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14689 }
14690 {
14691 if (temp2)
14692 delete arg2;
14693 }
14694 return resultobj;
14695 fail:
14696 {
14697 if (temp2)
14698 delete arg2;
14699 }
14700 return NULL;
14701 }
14702
14703
14704 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14705 PyObject *resultobj = 0;
14706 wxImage *arg1 = (wxImage *) 0 ;
14707 wxString *arg2 = 0 ;
14708 wxString *arg3 = 0 ;
14709 bool result;
14710 void *argp1 = 0 ;
14711 int res1 = 0 ;
14712 bool temp2 = false ;
14713 bool temp3 = false ;
14714 PyObject * obj0 = 0 ;
14715 PyObject * obj1 = 0 ;
14716 PyObject * obj2 = 0 ;
14717 char * kwnames[] = {
14718 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14719 };
14720
14721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14723 if (!SWIG_IsOK(res1)) {
14724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14725 }
14726 arg1 = reinterpret_cast< wxImage * >(argp1);
14727 {
14728 arg2 = wxString_in_helper(obj1);
14729 if (arg2 == NULL) SWIG_fail;
14730 temp2 = true;
14731 }
14732 {
14733 arg3 = wxString_in_helper(obj2);
14734 if (arg3 == NULL) SWIG_fail;
14735 temp3 = true;
14736 }
14737 {
14738 PyThreadState* __tstate = wxPyBeginAllowThreads();
14739 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14740 wxPyEndAllowThreads(__tstate);
14741 if (PyErr_Occurred()) SWIG_fail;
14742 }
14743 {
14744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14745 }
14746 {
14747 if (temp2)
14748 delete arg2;
14749 }
14750 {
14751 if (temp3)
14752 delete arg3;
14753 }
14754 return resultobj;
14755 fail:
14756 {
14757 if (temp2)
14758 delete arg2;
14759 }
14760 {
14761 if (temp3)
14762 delete arg3;
14763 }
14764 return NULL;
14765 }
14766
14767
14768 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14769 PyObject *resultobj = 0;
14770 wxInputStream *arg1 = 0 ;
14771 bool result;
14772 wxPyInputStream *temp1 ;
14773 bool created1 ;
14774 PyObject * obj0 = 0 ;
14775 char * kwnames[] = {
14776 (char *) "stream", NULL
14777 };
14778
14779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14780 {
14781 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14782 arg1 = temp1->m_wxis;
14783 created1 = false;
14784 } else {
14785 PyErr_Clear(); // clear the failure of the wxPyConvert above
14786 arg1 = wxPyCBInputStream_create(obj0, false);
14787 if (arg1 == NULL) {
14788 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14789 SWIG_fail;
14790 }
14791 created1 = true;
14792 }
14793 }
14794 {
14795 PyThreadState* __tstate = wxPyBeginAllowThreads();
14796 result = (bool)wxImage::CanRead(*arg1);
14797 wxPyEndAllowThreads(__tstate);
14798 if (PyErr_Occurred()) SWIG_fail;
14799 }
14800 {
14801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14802 }
14803 {
14804 if (created1) delete arg1;
14805 }
14806 return resultobj;
14807 fail:
14808 {
14809 if (created1) delete arg1;
14810 }
14811 return NULL;
14812 }
14813
14814
14815 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14816 PyObject *resultobj = 0;
14817 wxImage *arg1 = (wxImage *) 0 ;
14818 wxInputStream *arg2 = 0 ;
14819 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14820 int arg4 = (int) -1 ;
14821 bool result;
14822 void *argp1 = 0 ;
14823 int res1 = 0 ;
14824 wxPyInputStream *temp2 ;
14825 bool created2 ;
14826 long val3 ;
14827 int ecode3 = 0 ;
14828 int val4 ;
14829 int ecode4 = 0 ;
14830 PyObject * obj0 = 0 ;
14831 PyObject * obj1 = 0 ;
14832 PyObject * obj2 = 0 ;
14833 PyObject * obj3 = 0 ;
14834 char * kwnames[] = {
14835 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14836 };
14837
14838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14840 if (!SWIG_IsOK(res1)) {
14841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14842 }
14843 arg1 = reinterpret_cast< wxImage * >(argp1);
14844 {
14845 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14846 arg2 = temp2->m_wxis;
14847 created2 = false;
14848 } else {
14849 PyErr_Clear(); // clear the failure of the wxPyConvert above
14850 arg2 = wxPyCBInputStream_create(obj1, false);
14851 if (arg2 == NULL) {
14852 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14853 SWIG_fail;
14854 }
14855 created2 = true;
14856 }
14857 }
14858 if (obj2) {
14859 ecode3 = SWIG_AsVal_long(obj2, &val3);
14860 if (!SWIG_IsOK(ecode3)) {
14861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14862 }
14863 arg3 = static_cast< long >(val3);
14864 }
14865 if (obj3) {
14866 ecode4 = SWIG_AsVal_int(obj3, &val4);
14867 if (!SWIG_IsOK(ecode4)) {
14868 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14869 }
14870 arg4 = static_cast< int >(val4);
14871 }
14872 {
14873 PyThreadState* __tstate = wxPyBeginAllowThreads();
14874 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14875 wxPyEndAllowThreads(__tstate);
14876 if (PyErr_Occurred()) SWIG_fail;
14877 }
14878 {
14879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14880 }
14881 {
14882 if (created2) delete arg2;
14883 }
14884 return resultobj;
14885 fail:
14886 {
14887 if (created2) delete arg2;
14888 }
14889 return NULL;
14890 }
14891
14892
14893 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14894 PyObject *resultobj = 0;
14895 wxImage *arg1 = (wxImage *) 0 ;
14896 wxInputStream *arg2 = 0 ;
14897 wxString *arg3 = 0 ;
14898 int arg4 = (int) -1 ;
14899 bool result;
14900 void *argp1 = 0 ;
14901 int res1 = 0 ;
14902 wxPyInputStream *temp2 ;
14903 bool created2 ;
14904 bool temp3 = false ;
14905 int val4 ;
14906 int ecode4 = 0 ;
14907 PyObject * obj0 = 0 ;
14908 PyObject * obj1 = 0 ;
14909 PyObject * obj2 = 0 ;
14910 PyObject * obj3 = 0 ;
14911 char * kwnames[] = {
14912 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14913 };
14914
14915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14917 if (!SWIG_IsOK(res1)) {
14918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14919 }
14920 arg1 = reinterpret_cast< wxImage * >(argp1);
14921 {
14922 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14923 arg2 = temp2->m_wxis;
14924 created2 = false;
14925 } else {
14926 PyErr_Clear(); // clear the failure of the wxPyConvert above
14927 arg2 = wxPyCBInputStream_create(obj1, false);
14928 if (arg2 == NULL) {
14929 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14930 SWIG_fail;
14931 }
14932 created2 = true;
14933 }
14934 }
14935 {
14936 arg3 = wxString_in_helper(obj2);
14937 if (arg3 == NULL) SWIG_fail;
14938 temp3 = true;
14939 }
14940 if (obj3) {
14941 ecode4 = SWIG_AsVal_int(obj3, &val4);
14942 if (!SWIG_IsOK(ecode4)) {
14943 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14944 }
14945 arg4 = static_cast< int >(val4);
14946 }
14947 {
14948 PyThreadState* __tstate = wxPyBeginAllowThreads();
14949 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14950 wxPyEndAllowThreads(__tstate);
14951 if (PyErr_Occurred()) SWIG_fail;
14952 }
14953 {
14954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14955 }
14956 {
14957 if (created2) delete arg2;
14958 }
14959 {
14960 if (temp3)
14961 delete arg3;
14962 }
14963 return resultobj;
14964 fail:
14965 {
14966 if (created2) delete arg2;
14967 }
14968 {
14969 if (temp3)
14970 delete arg3;
14971 }
14972 return NULL;
14973 }
14974
14975
14976 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14977 PyObject *resultobj = 0;
14978 wxImage *arg1 = (wxImage *) 0 ;
14979 bool result;
14980 void *argp1 = 0 ;
14981 int res1 = 0 ;
14982 PyObject *swig_obj[1] ;
14983
14984 if (!args) SWIG_fail;
14985 swig_obj[0] = args;
14986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14987 if (!SWIG_IsOK(res1)) {
14988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14989 }
14990 arg1 = reinterpret_cast< wxImage * >(argp1);
14991 {
14992 PyThreadState* __tstate = wxPyBeginAllowThreads();
14993 result = (bool)(arg1)->Ok();
14994 wxPyEndAllowThreads(__tstate);
14995 if (PyErr_Occurred()) SWIG_fail;
14996 }
14997 {
14998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14999 }
15000 return resultobj;
15001 fail:
15002 return NULL;
15003 }
15004
15005
15006 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15007 PyObject *resultobj = 0;
15008 wxImage *arg1 = (wxImage *) 0 ;
15009 int result;
15010 void *argp1 = 0 ;
15011 int res1 = 0 ;
15012 PyObject *swig_obj[1] ;
15013
15014 if (!args) SWIG_fail;
15015 swig_obj[0] = args;
15016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15017 if (!SWIG_IsOK(res1)) {
15018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15019 }
15020 arg1 = reinterpret_cast< wxImage * >(argp1);
15021 {
15022 PyThreadState* __tstate = wxPyBeginAllowThreads();
15023 result = (int)(arg1)->GetWidth();
15024 wxPyEndAllowThreads(__tstate);
15025 if (PyErr_Occurred()) SWIG_fail;
15026 }
15027 resultobj = SWIG_From_int(static_cast< int >(result));
15028 return resultobj;
15029 fail:
15030 return NULL;
15031 }
15032
15033
15034 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15035 PyObject *resultobj = 0;
15036 wxImage *arg1 = (wxImage *) 0 ;
15037 int result;
15038 void *argp1 = 0 ;
15039 int res1 = 0 ;
15040 PyObject *swig_obj[1] ;
15041
15042 if (!args) SWIG_fail;
15043 swig_obj[0] = args;
15044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15045 if (!SWIG_IsOK(res1)) {
15046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15047 }
15048 arg1 = reinterpret_cast< wxImage * >(argp1);
15049 {
15050 PyThreadState* __tstate = wxPyBeginAllowThreads();
15051 result = (int)(arg1)->GetHeight();
15052 wxPyEndAllowThreads(__tstate);
15053 if (PyErr_Occurred()) SWIG_fail;
15054 }
15055 resultobj = SWIG_From_int(static_cast< int >(result));
15056 return resultobj;
15057 fail:
15058 return NULL;
15059 }
15060
15061
15062 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15063 PyObject *resultobj = 0;
15064 wxImage *arg1 = (wxImage *) 0 ;
15065 wxSize result;
15066 void *argp1 = 0 ;
15067 int res1 = 0 ;
15068 PyObject *swig_obj[1] ;
15069
15070 if (!args) SWIG_fail;
15071 swig_obj[0] = args;
15072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15073 if (!SWIG_IsOK(res1)) {
15074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15075 }
15076 arg1 = reinterpret_cast< wxImage * >(argp1);
15077 {
15078 PyThreadState* __tstate = wxPyBeginAllowThreads();
15079 result = wxImage_GetSize(arg1);
15080 wxPyEndAllowThreads(__tstate);
15081 if (PyErr_Occurred()) SWIG_fail;
15082 }
15083 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15084 return resultobj;
15085 fail:
15086 return NULL;
15087 }
15088
15089
15090 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15091 PyObject *resultobj = 0;
15092 wxImage *arg1 = (wxImage *) 0 ;
15093 wxRect *arg2 = 0 ;
15094 SwigValueWrapper<wxImage > result;
15095 void *argp1 = 0 ;
15096 int res1 = 0 ;
15097 wxRect temp2 ;
15098 PyObject * obj0 = 0 ;
15099 PyObject * obj1 = 0 ;
15100 char * kwnames[] = {
15101 (char *) "self",(char *) "rect", NULL
15102 };
15103
15104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15106 if (!SWIG_IsOK(res1)) {
15107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15108 }
15109 arg1 = reinterpret_cast< wxImage * >(argp1);
15110 {
15111 arg2 = &temp2;
15112 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15113 }
15114 {
15115 PyThreadState* __tstate = wxPyBeginAllowThreads();
15116 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15117 wxPyEndAllowThreads(__tstate);
15118 if (PyErr_Occurred()) SWIG_fail;
15119 }
15120 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15121 return resultobj;
15122 fail:
15123 return NULL;
15124 }
15125
15126
15127 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15128 PyObject *resultobj = 0;
15129 wxImage *arg1 = (wxImage *) 0 ;
15130 wxSize *arg2 = 0 ;
15131 wxPoint *arg3 = 0 ;
15132 int arg4 = (int) -1 ;
15133 int arg5 = (int) -1 ;
15134 int arg6 = (int) -1 ;
15135 SwigValueWrapper<wxImage > result;
15136 void *argp1 = 0 ;
15137 int res1 = 0 ;
15138 wxSize temp2 ;
15139 wxPoint temp3 ;
15140 int val4 ;
15141 int ecode4 = 0 ;
15142 int val5 ;
15143 int ecode5 = 0 ;
15144 int val6 ;
15145 int ecode6 = 0 ;
15146 PyObject * obj0 = 0 ;
15147 PyObject * obj1 = 0 ;
15148 PyObject * obj2 = 0 ;
15149 PyObject * obj3 = 0 ;
15150 PyObject * obj4 = 0 ;
15151 PyObject * obj5 = 0 ;
15152 char * kwnames[] = {
15153 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15154 };
15155
15156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15158 if (!SWIG_IsOK(res1)) {
15159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15160 }
15161 arg1 = reinterpret_cast< wxImage * >(argp1);
15162 {
15163 arg2 = &temp2;
15164 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15165 }
15166 {
15167 arg3 = &temp3;
15168 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15169 }
15170 if (obj3) {
15171 ecode4 = SWIG_AsVal_int(obj3, &val4);
15172 if (!SWIG_IsOK(ecode4)) {
15173 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15174 }
15175 arg4 = static_cast< int >(val4);
15176 }
15177 if (obj4) {
15178 ecode5 = SWIG_AsVal_int(obj4, &val5);
15179 if (!SWIG_IsOK(ecode5)) {
15180 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15181 }
15182 arg5 = static_cast< int >(val5);
15183 }
15184 if (obj5) {
15185 ecode6 = SWIG_AsVal_int(obj5, &val6);
15186 if (!SWIG_IsOK(ecode6)) {
15187 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15188 }
15189 arg6 = static_cast< int >(val6);
15190 }
15191 {
15192 PyThreadState* __tstate = wxPyBeginAllowThreads();
15193 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15194 wxPyEndAllowThreads(__tstate);
15195 if (PyErr_Occurred()) SWIG_fail;
15196 }
15197 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15198 return resultobj;
15199 fail:
15200 return NULL;
15201 }
15202
15203
15204 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15205 PyObject *resultobj = 0;
15206 wxImage *arg1 = (wxImage *) 0 ;
15207 SwigValueWrapper<wxImage > result;
15208 void *argp1 = 0 ;
15209 int res1 = 0 ;
15210 PyObject *swig_obj[1] ;
15211
15212 if (!args) SWIG_fail;
15213 swig_obj[0] = args;
15214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15215 if (!SWIG_IsOK(res1)) {
15216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15217 }
15218 arg1 = reinterpret_cast< wxImage * >(argp1);
15219 {
15220 PyThreadState* __tstate = wxPyBeginAllowThreads();
15221 result = (arg1)->Copy();
15222 wxPyEndAllowThreads(__tstate);
15223 if (PyErr_Occurred()) SWIG_fail;
15224 }
15225 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15226 return resultobj;
15227 fail:
15228 return NULL;
15229 }
15230
15231
15232 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15233 PyObject *resultobj = 0;
15234 wxImage *arg1 = (wxImage *) 0 ;
15235 wxImage *arg2 = 0 ;
15236 int arg3 ;
15237 int arg4 ;
15238 void *argp1 = 0 ;
15239 int res1 = 0 ;
15240 void *argp2 = 0 ;
15241 int res2 = 0 ;
15242 int val3 ;
15243 int ecode3 = 0 ;
15244 int val4 ;
15245 int ecode4 = 0 ;
15246 PyObject * obj0 = 0 ;
15247 PyObject * obj1 = 0 ;
15248 PyObject * obj2 = 0 ;
15249 PyObject * obj3 = 0 ;
15250 char * kwnames[] = {
15251 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15252 };
15253
15254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15256 if (!SWIG_IsOK(res1)) {
15257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15258 }
15259 arg1 = reinterpret_cast< wxImage * >(argp1);
15260 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15261 if (!SWIG_IsOK(res2)) {
15262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15263 }
15264 if (!argp2) {
15265 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15266 }
15267 arg2 = reinterpret_cast< wxImage * >(argp2);
15268 ecode3 = SWIG_AsVal_int(obj2, &val3);
15269 if (!SWIG_IsOK(ecode3)) {
15270 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15271 }
15272 arg3 = static_cast< int >(val3);
15273 ecode4 = SWIG_AsVal_int(obj3, &val4);
15274 if (!SWIG_IsOK(ecode4)) {
15275 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15276 }
15277 arg4 = static_cast< int >(val4);
15278 {
15279 PyThreadState* __tstate = wxPyBeginAllowThreads();
15280 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15281 wxPyEndAllowThreads(__tstate);
15282 if (PyErr_Occurred()) SWIG_fail;
15283 }
15284 resultobj = SWIG_Py_Void();
15285 return resultobj;
15286 fail:
15287 return NULL;
15288 }
15289
15290
15291 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15292 PyObject *resultobj = 0;
15293 wxImage *arg1 = (wxImage *) 0 ;
15294 PyObject *result = 0 ;
15295 void *argp1 = 0 ;
15296 int res1 = 0 ;
15297 PyObject *swig_obj[1] ;
15298
15299 if (!args) SWIG_fail;
15300 swig_obj[0] = args;
15301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15302 if (!SWIG_IsOK(res1)) {
15303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15304 }
15305 arg1 = reinterpret_cast< wxImage * >(argp1);
15306 {
15307 PyThreadState* __tstate = wxPyBeginAllowThreads();
15308 result = (PyObject *)wxImage_GetData(arg1);
15309 wxPyEndAllowThreads(__tstate);
15310 if (PyErr_Occurred()) SWIG_fail;
15311 }
15312 resultobj = result;
15313 return resultobj;
15314 fail:
15315 return NULL;
15316 }
15317
15318
15319 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15320 PyObject *resultobj = 0;
15321 wxImage *arg1 = (wxImage *) 0 ;
15322 buffer arg2 ;
15323 int arg3 ;
15324 void *argp1 = 0 ;
15325 int res1 = 0 ;
15326 PyObject * obj0 = 0 ;
15327 PyObject * obj1 = 0 ;
15328 char * kwnames[] = {
15329 (char *) "self",(char *) "data", NULL
15330 };
15331
15332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15334 if (!SWIG_IsOK(res1)) {
15335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15336 }
15337 arg1 = reinterpret_cast< wxImage * >(argp1);
15338 {
15339 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15340 }
15341 {
15342 PyThreadState* __tstate = wxPyBeginAllowThreads();
15343 wxImage_SetData(arg1,arg2,arg3);
15344 wxPyEndAllowThreads(__tstate);
15345 if (PyErr_Occurred()) SWIG_fail;
15346 }
15347 resultobj = SWIG_Py_Void();
15348 return resultobj;
15349 fail:
15350 return NULL;
15351 }
15352
15353
15354 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15355 PyObject *resultobj = 0;
15356 wxImage *arg1 = (wxImage *) 0 ;
15357 PyObject *result = 0 ;
15358 void *argp1 = 0 ;
15359 int res1 = 0 ;
15360 PyObject *swig_obj[1] ;
15361
15362 if (!args) SWIG_fail;
15363 swig_obj[0] = args;
15364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15365 if (!SWIG_IsOK(res1)) {
15366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15367 }
15368 arg1 = reinterpret_cast< wxImage * >(argp1);
15369 {
15370 PyThreadState* __tstate = wxPyBeginAllowThreads();
15371 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15372 wxPyEndAllowThreads(__tstate);
15373 if (PyErr_Occurred()) SWIG_fail;
15374 }
15375 resultobj = result;
15376 return resultobj;
15377 fail:
15378 return NULL;
15379 }
15380
15381
15382 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15383 PyObject *resultobj = 0;
15384 wxImage *arg1 = (wxImage *) 0 ;
15385 buffer arg2 ;
15386 int arg3 ;
15387 void *argp1 = 0 ;
15388 int res1 = 0 ;
15389 PyObject * obj0 = 0 ;
15390 PyObject * obj1 = 0 ;
15391 char * kwnames[] = {
15392 (char *) "self",(char *) "data", NULL
15393 };
15394
15395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15397 if (!SWIG_IsOK(res1)) {
15398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15399 }
15400 arg1 = reinterpret_cast< wxImage * >(argp1);
15401 {
15402 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15403 }
15404 {
15405 PyThreadState* __tstate = wxPyBeginAllowThreads();
15406 wxImage_SetDataBuffer(arg1,arg2,arg3);
15407 wxPyEndAllowThreads(__tstate);
15408 if (PyErr_Occurred()) SWIG_fail;
15409 }
15410 resultobj = SWIG_Py_Void();
15411 return resultobj;
15412 fail:
15413 return NULL;
15414 }
15415
15416
15417 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15418 PyObject *resultobj = 0;
15419 wxImage *arg1 = (wxImage *) 0 ;
15420 PyObject *result = 0 ;
15421 void *argp1 = 0 ;
15422 int res1 = 0 ;
15423 PyObject *swig_obj[1] ;
15424
15425 if (!args) SWIG_fail;
15426 swig_obj[0] = args;
15427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15428 if (!SWIG_IsOK(res1)) {
15429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15430 }
15431 arg1 = reinterpret_cast< wxImage * >(argp1);
15432 {
15433 PyThreadState* __tstate = wxPyBeginAllowThreads();
15434 result = (PyObject *)wxImage_GetAlphaData(arg1);
15435 wxPyEndAllowThreads(__tstate);
15436 if (PyErr_Occurred()) SWIG_fail;
15437 }
15438 resultobj = result;
15439 return resultobj;
15440 fail:
15441 return NULL;
15442 }
15443
15444
15445 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15446 PyObject *resultobj = 0;
15447 wxImage *arg1 = (wxImage *) 0 ;
15448 buffer arg2 ;
15449 int arg3 ;
15450 void *argp1 = 0 ;
15451 int res1 = 0 ;
15452 PyObject * obj0 = 0 ;
15453 PyObject * obj1 = 0 ;
15454 char * kwnames[] = {
15455 (char *) "self",(char *) "alpha", NULL
15456 };
15457
15458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15460 if (!SWIG_IsOK(res1)) {
15461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15462 }
15463 arg1 = reinterpret_cast< wxImage * >(argp1);
15464 {
15465 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15466 }
15467 {
15468 PyThreadState* __tstate = wxPyBeginAllowThreads();
15469 wxImage_SetAlphaData(arg1,arg2,arg3);
15470 wxPyEndAllowThreads(__tstate);
15471 if (PyErr_Occurred()) SWIG_fail;
15472 }
15473 resultobj = SWIG_Py_Void();
15474 return resultobj;
15475 fail:
15476 return NULL;
15477 }
15478
15479
15480 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15481 PyObject *resultobj = 0;
15482 wxImage *arg1 = (wxImage *) 0 ;
15483 PyObject *result = 0 ;
15484 void *argp1 = 0 ;
15485 int res1 = 0 ;
15486 PyObject *swig_obj[1] ;
15487
15488 if (!args) SWIG_fail;
15489 swig_obj[0] = args;
15490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15491 if (!SWIG_IsOK(res1)) {
15492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15493 }
15494 arg1 = reinterpret_cast< wxImage * >(argp1);
15495 {
15496 PyThreadState* __tstate = wxPyBeginAllowThreads();
15497 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15498 wxPyEndAllowThreads(__tstate);
15499 if (PyErr_Occurred()) SWIG_fail;
15500 }
15501 resultobj = result;
15502 return resultobj;
15503 fail:
15504 return NULL;
15505 }
15506
15507
15508 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15509 PyObject *resultobj = 0;
15510 wxImage *arg1 = (wxImage *) 0 ;
15511 buffer arg2 ;
15512 int arg3 ;
15513 void *argp1 = 0 ;
15514 int res1 = 0 ;
15515 PyObject * obj0 = 0 ;
15516 PyObject * obj1 = 0 ;
15517 char * kwnames[] = {
15518 (char *) "self",(char *) "alpha", NULL
15519 };
15520
15521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15523 if (!SWIG_IsOK(res1)) {
15524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15525 }
15526 arg1 = reinterpret_cast< wxImage * >(argp1);
15527 {
15528 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15529 }
15530 {
15531 PyThreadState* __tstate = wxPyBeginAllowThreads();
15532 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15533 wxPyEndAllowThreads(__tstate);
15534 if (PyErr_Occurred()) SWIG_fail;
15535 }
15536 resultobj = SWIG_Py_Void();
15537 return resultobj;
15538 fail:
15539 return NULL;
15540 }
15541
15542
15543 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15544 PyObject *resultobj = 0;
15545 wxImage *arg1 = (wxImage *) 0 ;
15546 byte arg2 ;
15547 byte arg3 ;
15548 byte arg4 ;
15549 void *argp1 = 0 ;
15550 int res1 = 0 ;
15551 unsigned char val2 ;
15552 int ecode2 = 0 ;
15553 unsigned char val3 ;
15554 int ecode3 = 0 ;
15555 unsigned char val4 ;
15556 int ecode4 = 0 ;
15557 PyObject * obj0 = 0 ;
15558 PyObject * obj1 = 0 ;
15559 PyObject * obj2 = 0 ;
15560 PyObject * obj3 = 0 ;
15561 char * kwnames[] = {
15562 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15563 };
15564
15565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15567 if (!SWIG_IsOK(res1)) {
15568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15569 }
15570 arg1 = reinterpret_cast< wxImage * >(argp1);
15571 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15572 if (!SWIG_IsOK(ecode2)) {
15573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15574 }
15575 arg2 = static_cast< byte >(val2);
15576 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15577 if (!SWIG_IsOK(ecode3)) {
15578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15579 }
15580 arg3 = static_cast< byte >(val3);
15581 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15582 if (!SWIG_IsOK(ecode4)) {
15583 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15584 }
15585 arg4 = static_cast< byte >(val4);
15586 {
15587 PyThreadState* __tstate = wxPyBeginAllowThreads();
15588 (arg1)->SetMaskColour(arg2,arg3,arg4);
15589 wxPyEndAllowThreads(__tstate);
15590 if (PyErr_Occurred()) SWIG_fail;
15591 }
15592 resultobj = SWIG_Py_Void();
15593 return resultobj;
15594 fail:
15595 return NULL;
15596 }
15597
15598
15599 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15600 PyObject *resultobj = 0;
15601 wxImage *arg1 = (wxImage *) 0 ;
15602 byte *arg2 = (byte *) 0 ;
15603 byte *arg3 = (byte *) 0 ;
15604 byte *arg4 = (byte *) 0 ;
15605 void *argp1 = 0 ;
15606 int res1 = 0 ;
15607 byte temp2 ;
15608 int res2 = SWIG_TMPOBJ ;
15609 byte temp3 ;
15610 int res3 = SWIG_TMPOBJ ;
15611 byte temp4 ;
15612 int res4 = SWIG_TMPOBJ ;
15613 PyObject *swig_obj[1] ;
15614
15615 arg2 = &temp2;
15616 arg3 = &temp3;
15617 arg4 = &temp4;
15618 if (!args) SWIG_fail;
15619 swig_obj[0] = args;
15620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15621 if (!SWIG_IsOK(res1)) {
15622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15623 }
15624 arg1 = reinterpret_cast< wxImage * >(argp1);
15625 {
15626 PyThreadState* __tstate = wxPyBeginAllowThreads();
15627 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15628 wxPyEndAllowThreads(__tstate);
15629 if (PyErr_Occurred()) SWIG_fail;
15630 }
15631 resultobj = SWIG_Py_Void();
15632 if (SWIG_IsTmpObj(res2)) {
15633 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15634 } else {
15635 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15636 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15637 }
15638 if (SWIG_IsTmpObj(res3)) {
15639 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15640 } else {
15641 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15642 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15643 }
15644 if (SWIG_IsTmpObj(res4)) {
15645 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15646 } else {
15647 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15648 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15649 }
15650 return resultobj;
15651 fail:
15652 return NULL;
15653 }
15654
15655
15656 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15657 PyObject *resultobj = 0;
15658 wxImage *arg1 = (wxImage *) 0 ;
15659 byte result;
15660 void *argp1 = 0 ;
15661 int res1 = 0 ;
15662 PyObject *swig_obj[1] ;
15663
15664 if (!args) SWIG_fail;
15665 swig_obj[0] = args;
15666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15667 if (!SWIG_IsOK(res1)) {
15668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15669 }
15670 arg1 = reinterpret_cast< wxImage * >(argp1);
15671 {
15672 PyThreadState* __tstate = wxPyBeginAllowThreads();
15673 result = (byte)(arg1)->GetMaskRed();
15674 wxPyEndAllowThreads(__tstate);
15675 if (PyErr_Occurred()) SWIG_fail;
15676 }
15677 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15678 return resultobj;
15679 fail:
15680 return NULL;
15681 }
15682
15683
15684 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15685 PyObject *resultobj = 0;
15686 wxImage *arg1 = (wxImage *) 0 ;
15687 byte result;
15688 void *argp1 = 0 ;
15689 int res1 = 0 ;
15690 PyObject *swig_obj[1] ;
15691
15692 if (!args) SWIG_fail;
15693 swig_obj[0] = args;
15694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15695 if (!SWIG_IsOK(res1)) {
15696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15697 }
15698 arg1 = reinterpret_cast< wxImage * >(argp1);
15699 {
15700 PyThreadState* __tstate = wxPyBeginAllowThreads();
15701 result = (byte)(arg1)->GetMaskGreen();
15702 wxPyEndAllowThreads(__tstate);
15703 if (PyErr_Occurred()) SWIG_fail;
15704 }
15705 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15706 return resultobj;
15707 fail:
15708 return NULL;
15709 }
15710
15711
15712 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15713 PyObject *resultobj = 0;
15714 wxImage *arg1 = (wxImage *) 0 ;
15715 byte result;
15716 void *argp1 = 0 ;
15717 int res1 = 0 ;
15718 PyObject *swig_obj[1] ;
15719
15720 if (!args) SWIG_fail;
15721 swig_obj[0] = args;
15722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15723 if (!SWIG_IsOK(res1)) {
15724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15725 }
15726 arg1 = reinterpret_cast< wxImage * >(argp1);
15727 {
15728 PyThreadState* __tstate = wxPyBeginAllowThreads();
15729 result = (byte)(arg1)->GetMaskBlue();
15730 wxPyEndAllowThreads(__tstate);
15731 if (PyErr_Occurred()) SWIG_fail;
15732 }
15733 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15734 return resultobj;
15735 fail:
15736 return NULL;
15737 }
15738
15739
15740 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15741 PyObject *resultobj = 0;
15742 wxImage *arg1 = (wxImage *) 0 ;
15743 bool arg2 = (bool) true ;
15744 void *argp1 = 0 ;
15745 int res1 = 0 ;
15746 bool val2 ;
15747 int ecode2 = 0 ;
15748 PyObject * obj0 = 0 ;
15749 PyObject * obj1 = 0 ;
15750 char * kwnames[] = {
15751 (char *) "self",(char *) "mask", NULL
15752 };
15753
15754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15756 if (!SWIG_IsOK(res1)) {
15757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15758 }
15759 arg1 = reinterpret_cast< wxImage * >(argp1);
15760 if (obj1) {
15761 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15762 if (!SWIG_IsOK(ecode2)) {
15763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15764 }
15765 arg2 = static_cast< bool >(val2);
15766 }
15767 {
15768 PyThreadState* __tstate = wxPyBeginAllowThreads();
15769 (arg1)->SetMask(arg2);
15770 wxPyEndAllowThreads(__tstate);
15771 if (PyErr_Occurred()) SWIG_fail;
15772 }
15773 resultobj = SWIG_Py_Void();
15774 return resultobj;
15775 fail:
15776 return NULL;
15777 }
15778
15779
15780 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15781 PyObject *resultobj = 0;
15782 wxImage *arg1 = (wxImage *) 0 ;
15783 bool result;
15784 void *argp1 = 0 ;
15785 int res1 = 0 ;
15786 PyObject *swig_obj[1] ;
15787
15788 if (!args) SWIG_fail;
15789 swig_obj[0] = args;
15790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15791 if (!SWIG_IsOK(res1)) {
15792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15793 }
15794 arg1 = reinterpret_cast< wxImage * >(argp1);
15795 {
15796 PyThreadState* __tstate = wxPyBeginAllowThreads();
15797 result = (bool)(arg1)->HasMask();
15798 wxPyEndAllowThreads(__tstate);
15799 if (PyErr_Occurred()) SWIG_fail;
15800 }
15801 {
15802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15803 }
15804 return resultobj;
15805 fail:
15806 return NULL;
15807 }
15808
15809
15810 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15811 PyObject *resultobj = 0;
15812 wxImage *arg1 = (wxImage *) 0 ;
15813 double arg2 ;
15814 wxPoint *arg3 = 0 ;
15815 bool arg4 = (bool) true ;
15816 wxPoint *arg5 = (wxPoint *) NULL ;
15817 SwigValueWrapper<wxImage > result;
15818 void *argp1 = 0 ;
15819 int res1 = 0 ;
15820 double val2 ;
15821 int ecode2 = 0 ;
15822 wxPoint temp3 ;
15823 bool val4 ;
15824 int ecode4 = 0 ;
15825 void *argp5 = 0 ;
15826 int res5 = 0 ;
15827 PyObject * obj0 = 0 ;
15828 PyObject * obj1 = 0 ;
15829 PyObject * obj2 = 0 ;
15830 PyObject * obj3 = 0 ;
15831 PyObject * obj4 = 0 ;
15832 char * kwnames[] = {
15833 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15834 };
15835
15836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15838 if (!SWIG_IsOK(res1)) {
15839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15840 }
15841 arg1 = reinterpret_cast< wxImage * >(argp1);
15842 ecode2 = SWIG_AsVal_double(obj1, &val2);
15843 if (!SWIG_IsOK(ecode2)) {
15844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15845 }
15846 arg2 = static_cast< double >(val2);
15847 {
15848 arg3 = &temp3;
15849 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15850 }
15851 if (obj3) {
15852 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15853 if (!SWIG_IsOK(ecode4)) {
15854 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15855 }
15856 arg4 = static_cast< bool >(val4);
15857 }
15858 if (obj4) {
15859 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15860 if (!SWIG_IsOK(res5)) {
15861 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15862 }
15863 arg5 = reinterpret_cast< wxPoint * >(argp5);
15864 }
15865 {
15866 PyThreadState* __tstate = wxPyBeginAllowThreads();
15867 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15868 wxPyEndAllowThreads(__tstate);
15869 if (PyErr_Occurred()) SWIG_fail;
15870 }
15871 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15872 return resultobj;
15873 fail:
15874 return NULL;
15875 }
15876
15877
15878 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15879 PyObject *resultobj = 0;
15880 wxImage *arg1 = (wxImage *) 0 ;
15881 bool arg2 = (bool) true ;
15882 SwigValueWrapper<wxImage > result;
15883 void *argp1 = 0 ;
15884 int res1 = 0 ;
15885 bool val2 ;
15886 int ecode2 = 0 ;
15887 PyObject * obj0 = 0 ;
15888 PyObject * obj1 = 0 ;
15889 char * kwnames[] = {
15890 (char *) "self",(char *) "clockwise", NULL
15891 };
15892
15893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15895 if (!SWIG_IsOK(res1)) {
15896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15897 }
15898 arg1 = reinterpret_cast< wxImage * >(argp1);
15899 if (obj1) {
15900 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15901 if (!SWIG_IsOK(ecode2)) {
15902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15903 }
15904 arg2 = static_cast< bool >(val2);
15905 }
15906 {
15907 PyThreadState* __tstate = wxPyBeginAllowThreads();
15908 result = (arg1)->Rotate90(arg2);
15909 wxPyEndAllowThreads(__tstate);
15910 if (PyErr_Occurred()) SWIG_fail;
15911 }
15912 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15913 return resultobj;
15914 fail:
15915 return NULL;
15916 }
15917
15918
15919 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15920 PyObject *resultobj = 0;
15921 wxImage *arg1 = (wxImage *) 0 ;
15922 bool arg2 = (bool) true ;
15923 SwigValueWrapper<wxImage > result;
15924 void *argp1 = 0 ;
15925 int res1 = 0 ;
15926 bool val2 ;
15927 int ecode2 = 0 ;
15928 PyObject * obj0 = 0 ;
15929 PyObject * obj1 = 0 ;
15930 char * kwnames[] = {
15931 (char *) "self",(char *) "horizontally", NULL
15932 };
15933
15934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15936 if (!SWIG_IsOK(res1)) {
15937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15938 }
15939 arg1 = reinterpret_cast< wxImage * >(argp1);
15940 if (obj1) {
15941 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15942 if (!SWIG_IsOK(ecode2)) {
15943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15944 }
15945 arg2 = static_cast< bool >(val2);
15946 }
15947 {
15948 PyThreadState* __tstate = wxPyBeginAllowThreads();
15949 result = (arg1)->Mirror(arg2);
15950 wxPyEndAllowThreads(__tstate);
15951 if (PyErr_Occurred()) SWIG_fail;
15952 }
15953 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15954 return resultobj;
15955 fail:
15956 return NULL;
15957 }
15958
15959
15960 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15961 PyObject *resultobj = 0;
15962 wxImage *arg1 = (wxImage *) 0 ;
15963 byte arg2 ;
15964 byte arg3 ;
15965 byte arg4 ;
15966 byte arg5 ;
15967 byte arg6 ;
15968 byte arg7 ;
15969 void *argp1 = 0 ;
15970 int res1 = 0 ;
15971 unsigned char val2 ;
15972 int ecode2 = 0 ;
15973 unsigned char val3 ;
15974 int ecode3 = 0 ;
15975 unsigned char val4 ;
15976 int ecode4 = 0 ;
15977 unsigned char val5 ;
15978 int ecode5 = 0 ;
15979 unsigned char val6 ;
15980 int ecode6 = 0 ;
15981 unsigned char val7 ;
15982 int ecode7 = 0 ;
15983 PyObject * obj0 = 0 ;
15984 PyObject * obj1 = 0 ;
15985 PyObject * obj2 = 0 ;
15986 PyObject * obj3 = 0 ;
15987 PyObject * obj4 = 0 ;
15988 PyObject * obj5 = 0 ;
15989 PyObject * obj6 = 0 ;
15990 char * kwnames[] = {
15991 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15992 };
15993
15994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15996 if (!SWIG_IsOK(res1)) {
15997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15998 }
15999 arg1 = reinterpret_cast< wxImage * >(argp1);
16000 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16001 if (!SWIG_IsOK(ecode2)) {
16002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16003 }
16004 arg2 = static_cast< byte >(val2);
16005 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16006 if (!SWIG_IsOK(ecode3)) {
16007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16008 }
16009 arg3 = static_cast< byte >(val3);
16010 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16011 if (!SWIG_IsOK(ecode4)) {
16012 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16013 }
16014 arg4 = static_cast< byte >(val4);
16015 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16016 if (!SWIG_IsOK(ecode5)) {
16017 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16018 }
16019 arg5 = static_cast< byte >(val5);
16020 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16021 if (!SWIG_IsOK(ecode6)) {
16022 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16023 }
16024 arg6 = static_cast< byte >(val6);
16025 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16026 if (!SWIG_IsOK(ecode7)) {
16027 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16028 }
16029 arg7 = static_cast< byte >(val7);
16030 {
16031 PyThreadState* __tstate = wxPyBeginAllowThreads();
16032 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16033 wxPyEndAllowThreads(__tstate);
16034 if (PyErr_Occurred()) SWIG_fail;
16035 }
16036 resultobj = SWIG_Py_Void();
16037 return resultobj;
16038 fail:
16039 return NULL;
16040 }
16041
16042
16043 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16044 PyObject *resultobj = 0;
16045 wxImage *arg1 = (wxImage *) 0 ;
16046 double arg2 = (double) 0.299 ;
16047 double arg3 = (double) 0.587 ;
16048 double arg4 = (double) 0.114 ;
16049 SwigValueWrapper<wxImage > result;
16050 void *argp1 = 0 ;
16051 int res1 = 0 ;
16052 double val2 ;
16053 int ecode2 = 0 ;
16054 double val3 ;
16055 int ecode3 = 0 ;
16056 double val4 ;
16057 int ecode4 = 0 ;
16058 PyObject * obj0 = 0 ;
16059 PyObject * obj1 = 0 ;
16060 PyObject * obj2 = 0 ;
16061 PyObject * obj3 = 0 ;
16062 char * kwnames[] = {
16063 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16064 };
16065
16066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16068 if (!SWIG_IsOK(res1)) {
16069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16070 }
16071 arg1 = reinterpret_cast< wxImage * >(argp1);
16072 if (obj1) {
16073 ecode2 = SWIG_AsVal_double(obj1, &val2);
16074 if (!SWIG_IsOK(ecode2)) {
16075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16076 }
16077 arg2 = static_cast< double >(val2);
16078 }
16079 if (obj2) {
16080 ecode3 = SWIG_AsVal_double(obj2, &val3);
16081 if (!SWIG_IsOK(ecode3)) {
16082 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16083 }
16084 arg3 = static_cast< double >(val3);
16085 }
16086 if (obj3) {
16087 ecode4 = SWIG_AsVal_double(obj3, &val4);
16088 if (!SWIG_IsOK(ecode4)) {
16089 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16090 }
16091 arg4 = static_cast< double >(val4);
16092 }
16093 {
16094 PyThreadState* __tstate = wxPyBeginAllowThreads();
16095 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16096 wxPyEndAllowThreads(__tstate);
16097 if (PyErr_Occurred()) SWIG_fail;
16098 }
16099 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16100 return resultobj;
16101 fail:
16102 return NULL;
16103 }
16104
16105
16106 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16107 PyObject *resultobj = 0;
16108 wxImage *arg1 = (wxImage *) 0 ;
16109 byte arg2 ;
16110 byte arg3 ;
16111 byte arg4 ;
16112 SwigValueWrapper<wxImage > result;
16113 void *argp1 = 0 ;
16114 int res1 = 0 ;
16115 unsigned char val2 ;
16116 int ecode2 = 0 ;
16117 unsigned char val3 ;
16118 int ecode3 = 0 ;
16119 unsigned char val4 ;
16120 int ecode4 = 0 ;
16121 PyObject * obj0 = 0 ;
16122 PyObject * obj1 = 0 ;
16123 PyObject * obj2 = 0 ;
16124 PyObject * obj3 = 0 ;
16125 char * kwnames[] = {
16126 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16127 };
16128
16129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16131 if (!SWIG_IsOK(res1)) {
16132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16133 }
16134 arg1 = reinterpret_cast< wxImage * >(argp1);
16135 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16136 if (!SWIG_IsOK(ecode2)) {
16137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16138 }
16139 arg2 = static_cast< byte >(val2);
16140 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16141 if (!SWIG_IsOK(ecode3)) {
16142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16143 }
16144 arg3 = static_cast< byte >(val3);
16145 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16146 if (!SWIG_IsOK(ecode4)) {
16147 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16148 }
16149 arg4 = static_cast< byte >(val4);
16150 {
16151 PyThreadState* __tstate = wxPyBeginAllowThreads();
16152 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16153 wxPyEndAllowThreads(__tstate);
16154 if (PyErr_Occurred()) SWIG_fail;
16155 }
16156 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16157 return resultobj;
16158 fail:
16159 return NULL;
16160 }
16161
16162
16163 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16164 PyObject *resultobj = 0;
16165 wxImage *arg1 = (wxImage *) 0 ;
16166 wxString *arg2 = 0 ;
16167 wxString *arg3 = 0 ;
16168 void *argp1 = 0 ;
16169 int res1 = 0 ;
16170 bool temp2 = false ;
16171 bool temp3 = false ;
16172 PyObject * obj0 = 0 ;
16173 PyObject * obj1 = 0 ;
16174 PyObject * obj2 = 0 ;
16175 char * kwnames[] = {
16176 (char *) "self",(char *) "name",(char *) "value", NULL
16177 };
16178
16179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16181 if (!SWIG_IsOK(res1)) {
16182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16183 }
16184 arg1 = reinterpret_cast< wxImage * >(argp1);
16185 {
16186 arg2 = wxString_in_helper(obj1);
16187 if (arg2 == NULL) SWIG_fail;
16188 temp2 = true;
16189 }
16190 {
16191 arg3 = wxString_in_helper(obj2);
16192 if (arg3 == NULL) SWIG_fail;
16193 temp3 = true;
16194 }
16195 {
16196 PyThreadState* __tstate = wxPyBeginAllowThreads();
16197 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16198 wxPyEndAllowThreads(__tstate);
16199 if (PyErr_Occurred()) SWIG_fail;
16200 }
16201 resultobj = SWIG_Py_Void();
16202 {
16203 if (temp2)
16204 delete arg2;
16205 }
16206 {
16207 if (temp3)
16208 delete arg3;
16209 }
16210 return resultobj;
16211 fail:
16212 {
16213 if (temp2)
16214 delete arg2;
16215 }
16216 {
16217 if (temp3)
16218 delete arg3;
16219 }
16220 return NULL;
16221 }
16222
16223
16224 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16225 PyObject *resultobj = 0;
16226 wxImage *arg1 = (wxImage *) 0 ;
16227 wxString *arg2 = 0 ;
16228 int arg3 ;
16229 void *argp1 = 0 ;
16230 int res1 = 0 ;
16231 bool temp2 = false ;
16232 int val3 ;
16233 int ecode3 = 0 ;
16234 PyObject * obj0 = 0 ;
16235 PyObject * obj1 = 0 ;
16236 PyObject * obj2 = 0 ;
16237 char * kwnames[] = {
16238 (char *) "self",(char *) "name",(char *) "value", NULL
16239 };
16240
16241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16243 if (!SWIG_IsOK(res1)) {
16244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16245 }
16246 arg1 = reinterpret_cast< wxImage * >(argp1);
16247 {
16248 arg2 = wxString_in_helper(obj1);
16249 if (arg2 == NULL) SWIG_fail;
16250 temp2 = true;
16251 }
16252 ecode3 = SWIG_AsVal_int(obj2, &val3);
16253 if (!SWIG_IsOK(ecode3)) {
16254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16255 }
16256 arg3 = static_cast< int >(val3);
16257 {
16258 PyThreadState* __tstate = wxPyBeginAllowThreads();
16259 (arg1)->SetOption((wxString const &)*arg2,arg3);
16260 wxPyEndAllowThreads(__tstate);
16261 if (PyErr_Occurred()) SWIG_fail;
16262 }
16263 resultobj = SWIG_Py_Void();
16264 {
16265 if (temp2)
16266 delete arg2;
16267 }
16268 return resultobj;
16269 fail:
16270 {
16271 if (temp2)
16272 delete arg2;
16273 }
16274 return NULL;
16275 }
16276
16277
16278 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16279 PyObject *resultobj = 0;
16280 wxImage *arg1 = (wxImage *) 0 ;
16281 wxString *arg2 = 0 ;
16282 wxString result;
16283 void *argp1 = 0 ;
16284 int res1 = 0 ;
16285 bool temp2 = false ;
16286 PyObject * obj0 = 0 ;
16287 PyObject * obj1 = 0 ;
16288 char * kwnames[] = {
16289 (char *) "self",(char *) "name", NULL
16290 };
16291
16292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16294 if (!SWIG_IsOK(res1)) {
16295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16296 }
16297 arg1 = reinterpret_cast< wxImage * >(argp1);
16298 {
16299 arg2 = wxString_in_helper(obj1);
16300 if (arg2 == NULL) SWIG_fail;
16301 temp2 = true;
16302 }
16303 {
16304 PyThreadState* __tstate = wxPyBeginAllowThreads();
16305 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16306 wxPyEndAllowThreads(__tstate);
16307 if (PyErr_Occurred()) SWIG_fail;
16308 }
16309 {
16310 #if wxUSE_UNICODE
16311 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16312 #else
16313 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16314 #endif
16315 }
16316 {
16317 if (temp2)
16318 delete arg2;
16319 }
16320 return resultobj;
16321 fail:
16322 {
16323 if (temp2)
16324 delete arg2;
16325 }
16326 return NULL;
16327 }
16328
16329
16330 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16331 PyObject *resultobj = 0;
16332 wxImage *arg1 = (wxImage *) 0 ;
16333 wxString *arg2 = 0 ;
16334 int result;
16335 void *argp1 = 0 ;
16336 int res1 = 0 ;
16337 bool temp2 = false ;
16338 PyObject * obj0 = 0 ;
16339 PyObject * obj1 = 0 ;
16340 char * kwnames[] = {
16341 (char *) "self",(char *) "name", NULL
16342 };
16343
16344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16346 if (!SWIG_IsOK(res1)) {
16347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16348 }
16349 arg1 = reinterpret_cast< wxImage * >(argp1);
16350 {
16351 arg2 = wxString_in_helper(obj1);
16352 if (arg2 == NULL) SWIG_fail;
16353 temp2 = true;
16354 }
16355 {
16356 PyThreadState* __tstate = wxPyBeginAllowThreads();
16357 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16358 wxPyEndAllowThreads(__tstate);
16359 if (PyErr_Occurred()) SWIG_fail;
16360 }
16361 resultobj = SWIG_From_int(static_cast< int >(result));
16362 {
16363 if (temp2)
16364 delete arg2;
16365 }
16366 return resultobj;
16367 fail:
16368 {
16369 if (temp2)
16370 delete arg2;
16371 }
16372 return NULL;
16373 }
16374
16375
16376 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16377 PyObject *resultobj = 0;
16378 wxImage *arg1 = (wxImage *) 0 ;
16379 wxString *arg2 = 0 ;
16380 bool result;
16381 void *argp1 = 0 ;
16382 int res1 = 0 ;
16383 bool temp2 = false ;
16384 PyObject * obj0 = 0 ;
16385 PyObject * obj1 = 0 ;
16386 char * kwnames[] = {
16387 (char *) "self",(char *) "name", NULL
16388 };
16389
16390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16392 if (!SWIG_IsOK(res1)) {
16393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16394 }
16395 arg1 = reinterpret_cast< wxImage * >(argp1);
16396 {
16397 arg2 = wxString_in_helper(obj1);
16398 if (arg2 == NULL) SWIG_fail;
16399 temp2 = true;
16400 }
16401 {
16402 PyThreadState* __tstate = wxPyBeginAllowThreads();
16403 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16404 wxPyEndAllowThreads(__tstate);
16405 if (PyErr_Occurred()) SWIG_fail;
16406 }
16407 {
16408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16409 }
16410 {
16411 if (temp2)
16412 delete arg2;
16413 }
16414 return resultobj;
16415 fail:
16416 {
16417 if (temp2)
16418 delete arg2;
16419 }
16420 return NULL;
16421 }
16422
16423
16424 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16425 PyObject *resultobj = 0;
16426 wxImage *arg1 = (wxImage *) 0 ;
16427 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16428 unsigned long result;
16429 void *argp1 = 0 ;
16430 int res1 = 0 ;
16431 unsigned long val2 ;
16432 int ecode2 = 0 ;
16433 PyObject * obj0 = 0 ;
16434 PyObject * obj1 = 0 ;
16435 char * kwnames[] = {
16436 (char *) "self",(char *) "stopafter", NULL
16437 };
16438
16439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16441 if (!SWIG_IsOK(res1)) {
16442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16443 }
16444 arg1 = reinterpret_cast< wxImage * >(argp1);
16445 if (obj1) {
16446 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16447 if (!SWIG_IsOK(ecode2)) {
16448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16449 }
16450 arg2 = static_cast< unsigned long >(val2);
16451 }
16452 {
16453 PyThreadState* __tstate = wxPyBeginAllowThreads();
16454 result = (unsigned long)(arg1)->CountColours(arg2);
16455 wxPyEndAllowThreads(__tstate);
16456 if (PyErr_Occurred()) SWIG_fail;
16457 }
16458 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16459 return resultobj;
16460 fail:
16461 return NULL;
16462 }
16463
16464
16465 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16466 PyObject *resultobj = 0;
16467 wxImage *arg1 = (wxImage *) 0 ;
16468 wxImageHistogram *arg2 = 0 ;
16469 unsigned long result;
16470 void *argp1 = 0 ;
16471 int res1 = 0 ;
16472 void *argp2 = 0 ;
16473 int res2 = 0 ;
16474 PyObject * obj0 = 0 ;
16475 PyObject * obj1 = 0 ;
16476 char * kwnames[] = {
16477 (char *) "self",(char *) "h", NULL
16478 };
16479
16480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16482 if (!SWIG_IsOK(res1)) {
16483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16484 }
16485 arg1 = reinterpret_cast< wxImage * >(argp1);
16486 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16487 if (!SWIG_IsOK(res2)) {
16488 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16489 }
16490 if (!argp2) {
16491 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16492 }
16493 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16494 {
16495 PyThreadState* __tstate = wxPyBeginAllowThreads();
16496 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16497 wxPyEndAllowThreads(__tstate);
16498 if (PyErr_Occurred()) SWIG_fail;
16499 }
16500 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16501 return resultobj;
16502 fail:
16503 return NULL;
16504 }
16505
16506
16507 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16508 PyObject *resultobj = 0;
16509 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16510 void *argp1 = 0 ;
16511 int res1 = 0 ;
16512 PyObject * obj0 = 0 ;
16513 char * kwnames[] = {
16514 (char *) "handler", NULL
16515 };
16516
16517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16519 if (!SWIG_IsOK(res1)) {
16520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16521 }
16522 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16523 {
16524 PyThreadState* __tstate = wxPyBeginAllowThreads();
16525 wxImage::AddHandler(arg1);
16526 wxPyEndAllowThreads(__tstate);
16527 if (PyErr_Occurred()) SWIG_fail;
16528 }
16529 resultobj = SWIG_Py_Void();
16530 return resultobj;
16531 fail:
16532 return NULL;
16533 }
16534
16535
16536 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16537 PyObject *resultobj = 0;
16538 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16539 void *argp1 = 0 ;
16540 int res1 = 0 ;
16541 PyObject * obj0 = 0 ;
16542 char * kwnames[] = {
16543 (char *) "handler", NULL
16544 };
16545
16546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16548 if (!SWIG_IsOK(res1)) {
16549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16550 }
16551 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16552 {
16553 PyThreadState* __tstate = wxPyBeginAllowThreads();
16554 wxImage::InsertHandler(arg1);
16555 wxPyEndAllowThreads(__tstate);
16556 if (PyErr_Occurred()) SWIG_fail;
16557 }
16558 resultobj = SWIG_Py_Void();
16559 return resultobj;
16560 fail:
16561 return NULL;
16562 }
16563
16564
16565 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16566 PyObject *resultobj = 0;
16567 wxString *arg1 = 0 ;
16568 bool result;
16569 bool temp1 = false ;
16570 PyObject * obj0 = 0 ;
16571 char * kwnames[] = {
16572 (char *) "name", NULL
16573 };
16574
16575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16576 {
16577 arg1 = wxString_in_helper(obj0);
16578 if (arg1 == NULL) SWIG_fail;
16579 temp1 = true;
16580 }
16581 {
16582 PyThreadState* __tstate = wxPyBeginAllowThreads();
16583 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16584 wxPyEndAllowThreads(__tstate);
16585 if (PyErr_Occurred()) SWIG_fail;
16586 }
16587 {
16588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16589 }
16590 {
16591 if (temp1)
16592 delete arg1;
16593 }
16594 return resultobj;
16595 fail:
16596 {
16597 if (temp1)
16598 delete arg1;
16599 }
16600 return NULL;
16601 }
16602
16603
16604 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16605 PyObject *resultobj = 0;
16606 PyObject *result = 0 ;
16607
16608 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16609 {
16610 PyThreadState* __tstate = wxPyBeginAllowThreads();
16611 result = (PyObject *)wxImage_GetHandlers();
16612 wxPyEndAllowThreads(__tstate);
16613 if (PyErr_Occurred()) SWIG_fail;
16614 }
16615 resultobj = result;
16616 return resultobj;
16617 fail:
16618 return NULL;
16619 }
16620
16621
16622 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16623 PyObject *resultobj = 0;
16624 wxString result;
16625
16626 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16627 {
16628 PyThreadState* __tstate = wxPyBeginAllowThreads();
16629 result = wxImage::GetImageExtWildcard();
16630 wxPyEndAllowThreads(__tstate);
16631 if (PyErr_Occurred()) SWIG_fail;
16632 }
16633 {
16634 #if wxUSE_UNICODE
16635 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16636 #else
16637 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16638 #endif
16639 }
16640 return resultobj;
16641 fail:
16642 return NULL;
16643 }
16644
16645
16646 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16647 PyObject *resultobj = 0;
16648 wxImage *arg1 = (wxImage *) 0 ;
16649 int arg2 = (int) -1 ;
16650 wxBitmap result;
16651 void *argp1 = 0 ;
16652 int res1 = 0 ;
16653 int val2 ;
16654 int ecode2 = 0 ;
16655 PyObject * obj0 = 0 ;
16656 PyObject * obj1 = 0 ;
16657 char * kwnames[] = {
16658 (char *) "self",(char *) "depth", NULL
16659 };
16660
16661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16663 if (!SWIG_IsOK(res1)) {
16664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16665 }
16666 arg1 = reinterpret_cast< wxImage * >(argp1);
16667 if (obj1) {
16668 ecode2 = SWIG_AsVal_int(obj1, &val2);
16669 if (!SWIG_IsOK(ecode2)) {
16670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16671 }
16672 arg2 = static_cast< int >(val2);
16673 }
16674 {
16675 if (!wxPyCheckForApp()) SWIG_fail;
16676 PyThreadState* __tstate = wxPyBeginAllowThreads();
16677 result = wxImage_ConvertToBitmap(arg1,arg2);
16678 wxPyEndAllowThreads(__tstate);
16679 if (PyErr_Occurred()) SWIG_fail;
16680 }
16681 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16682 return resultobj;
16683 fail:
16684 return NULL;
16685 }
16686
16687
16688 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16689 PyObject *resultobj = 0;
16690 wxImage *arg1 = (wxImage *) 0 ;
16691 byte arg2 ;
16692 byte arg3 ;
16693 byte arg4 ;
16694 wxBitmap result;
16695 void *argp1 = 0 ;
16696 int res1 = 0 ;
16697 unsigned char val2 ;
16698 int ecode2 = 0 ;
16699 unsigned char val3 ;
16700 int ecode3 = 0 ;
16701 unsigned char val4 ;
16702 int ecode4 = 0 ;
16703 PyObject * obj0 = 0 ;
16704 PyObject * obj1 = 0 ;
16705 PyObject * obj2 = 0 ;
16706 PyObject * obj3 = 0 ;
16707 char * kwnames[] = {
16708 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16709 };
16710
16711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16713 if (!SWIG_IsOK(res1)) {
16714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16715 }
16716 arg1 = reinterpret_cast< wxImage * >(argp1);
16717 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16718 if (!SWIG_IsOK(ecode2)) {
16719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16720 }
16721 arg2 = static_cast< byte >(val2);
16722 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16723 if (!SWIG_IsOK(ecode3)) {
16724 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16725 }
16726 arg3 = static_cast< byte >(val3);
16727 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16728 if (!SWIG_IsOK(ecode4)) {
16729 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16730 }
16731 arg4 = static_cast< byte >(val4);
16732 {
16733 if (!wxPyCheckForApp()) SWIG_fail;
16734 PyThreadState* __tstate = wxPyBeginAllowThreads();
16735 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16736 wxPyEndAllowThreads(__tstate);
16737 if (PyErr_Occurred()) SWIG_fail;
16738 }
16739 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16740 return resultobj;
16741 fail:
16742 return NULL;
16743 }
16744
16745
16746 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16747 PyObject *resultobj = 0;
16748 wxImage *arg1 = (wxImage *) 0 ;
16749 double arg2 ;
16750 void *argp1 = 0 ;
16751 int res1 = 0 ;
16752 double val2 ;
16753 int ecode2 = 0 ;
16754 PyObject * obj0 = 0 ;
16755 PyObject * obj1 = 0 ;
16756 char * kwnames[] = {
16757 (char *) "self",(char *) "angle", NULL
16758 };
16759
16760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16762 if (!SWIG_IsOK(res1)) {
16763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16764 }
16765 arg1 = reinterpret_cast< wxImage * >(argp1);
16766 ecode2 = SWIG_AsVal_double(obj1, &val2);
16767 if (!SWIG_IsOK(ecode2)) {
16768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16769 }
16770 arg2 = static_cast< double >(val2);
16771 {
16772 PyThreadState* __tstate = wxPyBeginAllowThreads();
16773 (arg1)->RotateHue(arg2);
16774 wxPyEndAllowThreads(__tstate);
16775 if (PyErr_Occurred()) SWIG_fail;
16776 }
16777 resultobj = SWIG_Py_Void();
16778 return resultobj;
16779 fail:
16780 return NULL;
16781 }
16782
16783
16784 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16785 PyObject *resultobj = 0;
16786 wxImage_RGBValue arg1 ;
16787 wxImage_HSVValue result;
16788 void *argp1 ;
16789 int res1 = 0 ;
16790 PyObject * obj0 = 0 ;
16791 char * kwnames[] = {
16792 (char *) "rgb", NULL
16793 };
16794
16795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16796 {
16797 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16798 if (!SWIG_IsOK(res1)) {
16799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16800 }
16801 if (!argp1) {
16802 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16803 } else {
16804 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16805 arg1 = *temp;
16806 if (SWIG_IsNewObj(res1)) delete temp;
16807 }
16808 }
16809 {
16810 PyThreadState* __tstate = wxPyBeginAllowThreads();
16811 result = wxImage::RGBtoHSV(arg1);
16812 wxPyEndAllowThreads(__tstate);
16813 if (PyErr_Occurred()) SWIG_fail;
16814 }
16815 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16816 return resultobj;
16817 fail:
16818 return NULL;
16819 }
16820
16821
16822 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16823 PyObject *resultobj = 0;
16824 wxImage_HSVValue arg1 ;
16825 wxImage_RGBValue result;
16826 void *argp1 ;
16827 int res1 = 0 ;
16828 PyObject * obj0 = 0 ;
16829 char * kwnames[] = {
16830 (char *) "hsv", NULL
16831 };
16832
16833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16834 {
16835 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16836 if (!SWIG_IsOK(res1)) {
16837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16838 }
16839 if (!argp1) {
16840 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16841 } else {
16842 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16843 arg1 = *temp;
16844 if (SWIG_IsNewObj(res1)) delete temp;
16845 }
16846 }
16847 {
16848 PyThreadState* __tstate = wxPyBeginAllowThreads();
16849 result = wxImage::HSVtoRGB(arg1);
16850 wxPyEndAllowThreads(__tstate);
16851 if (PyErr_Occurred()) SWIG_fail;
16852 }
16853 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16854 return resultobj;
16855 fail:
16856 return NULL;
16857 }
16858
16859
16860 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16861 PyObject *obj;
16862 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16863 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16864 return SWIG_Py_Void();
16865 }
16866
16867 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16868 return SWIG_Python_InitShadowInstance(args);
16869 }
16870
16871 SWIGINTERN int NullImage_set(PyObject *) {
16872 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16873 return 1;
16874 }
16875
16876
16877 SWIGINTERN PyObject *NullImage_get(void) {
16878 PyObject *pyobj = 0;
16879
16880 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16881 return pyobj;
16882 }
16883
16884
16885 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16886 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16887 return 1;
16888 }
16889
16890
16891 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16892 PyObject *pyobj = 0;
16893
16894 {
16895 #if wxUSE_UNICODE
16896 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16897 #else
16898 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16899 #endif
16900 }
16901 return pyobj;
16902 }
16903
16904
16905 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16906 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16907 return 1;
16908 }
16909
16910
16911 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16912 PyObject *pyobj = 0;
16913
16914 {
16915 #if wxUSE_UNICODE
16916 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16917 #else
16918 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16919 #endif
16920 }
16921 return pyobj;
16922 }
16923
16924
16925 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16926 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16927 return 1;
16928 }
16929
16930
16931 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16932 PyObject *pyobj = 0;
16933
16934 {
16935 #if wxUSE_UNICODE
16936 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16937 #else
16938 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16939 #endif
16940 }
16941 return pyobj;
16942 }
16943
16944
16945 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16946 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16947 return 1;
16948 }
16949
16950
16951 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16952 PyObject *pyobj = 0;
16953
16954 {
16955 #if wxUSE_UNICODE
16956 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16957 #else
16958 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16959 #endif
16960 }
16961 return pyobj;
16962 }
16963
16964
16965 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16966 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16967 return 1;
16968 }
16969
16970
16971 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16972 PyObject *pyobj = 0;
16973
16974 {
16975 #if wxUSE_UNICODE
16976 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16977 #else
16978 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16979 #endif
16980 }
16981 return pyobj;
16982 }
16983
16984
16985 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16986 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16987 return 1;
16988 }
16989
16990
16991 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16992 PyObject *pyobj = 0;
16993
16994 {
16995 #if wxUSE_UNICODE
16996 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16997 #else
16998 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16999 #endif
17000 }
17001 return pyobj;
17002 }
17003
17004
17005 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17006 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17007 return 1;
17008 }
17009
17010
17011 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17012 PyObject *pyobj = 0;
17013
17014 {
17015 #if wxUSE_UNICODE
17016 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17017 #else
17018 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17019 #endif
17020 }
17021 return pyobj;
17022 }
17023
17024
17025 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17026 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17027 return 1;
17028 }
17029
17030
17031 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17032 PyObject *pyobj = 0;
17033
17034 {
17035 #if wxUSE_UNICODE
17036 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17037 #else
17038 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17039 #endif
17040 }
17041 return pyobj;
17042 }
17043
17044
17045 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17046 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17047 return 1;
17048 }
17049
17050
17051 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17052 PyObject *pyobj = 0;
17053
17054 {
17055 #if wxUSE_UNICODE
17056 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17057 #else
17058 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17059 #endif
17060 }
17061 return pyobj;
17062 }
17063
17064
17065 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17066 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17067 return 1;
17068 }
17069
17070
17071 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17072 PyObject *pyobj = 0;
17073
17074 {
17075 #if wxUSE_UNICODE
17076 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17077 #else
17078 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17079 #endif
17080 }
17081 return pyobj;
17082 }
17083
17084
17085 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17086 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17087 return 1;
17088 }
17089
17090
17091 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17092 PyObject *pyobj = 0;
17093
17094 {
17095 #if wxUSE_UNICODE
17096 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17097 #else
17098 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17099 #endif
17100 }
17101 return pyobj;
17102 }
17103
17104
17105 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17106 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17107 return 1;
17108 }
17109
17110
17111 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17112 PyObject *pyobj = 0;
17113
17114 {
17115 #if wxUSE_UNICODE
17116 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17117 #else
17118 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17119 #endif
17120 }
17121 return pyobj;
17122 }
17123
17124
17125 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17126 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17127 return 1;
17128 }
17129
17130
17131 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17132 PyObject *pyobj = 0;
17133
17134 {
17135 #if wxUSE_UNICODE
17136 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17137 #else
17138 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17139 #endif
17140 }
17141 return pyobj;
17142 }
17143
17144
17145 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17146 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17147 return 1;
17148 }
17149
17150
17151 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17152 PyObject *pyobj = 0;
17153
17154 {
17155 #if wxUSE_UNICODE
17156 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17157 #else
17158 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17159 #endif
17160 }
17161 return pyobj;
17162 }
17163
17164
17165 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17166 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17167 return 1;
17168 }
17169
17170
17171 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17172 PyObject *pyobj = 0;
17173
17174 {
17175 #if wxUSE_UNICODE
17176 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17177 #else
17178 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17179 #endif
17180 }
17181 return pyobj;
17182 }
17183
17184
17185 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17186 PyObject *resultobj = 0;
17187 wxBMPHandler *result = 0 ;
17188
17189 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17190 {
17191 PyThreadState* __tstate = wxPyBeginAllowThreads();
17192 result = (wxBMPHandler *)new wxBMPHandler();
17193 wxPyEndAllowThreads(__tstate);
17194 if (PyErr_Occurred()) SWIG_fail;
17195 }
17196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17197 return resultobj;
17198 fail:
17199 return NULL;
17200 }
17201
17202
17203 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17204 PyObject *obj;
17205 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17206 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17207 return SWIG_Py_Void();
17208 }
17209
17210 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17211 return SWIG_Python_InitShadowInstance(args);
17212 }
17213
17214 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17215 PyObject *resultobj = 0;
17216 wxICOHandler *result = 0 ;
17217
17218 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17219 {
17220 PyThreadState* __tstate = wxPyBeginAllowThreads();
17221 result = (wxICOHandler *)new wxICOHandler();
17222 wxPyEndAllowThreads(__tstate);
17223 if (PyErr_Occurred()) SWIG_fail;
17224 }
17225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17226 return resultobj;
17227 fail:
17228 return NULL;
17229 }
17230
17231
17232 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17233 PyObject *obj;
17234 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17235 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17236 return SWIG_Py_Void();
17237 }
17238
17239 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17240 return SWIG_Python_InitShadowInstance(args);
17241 }
17242
17243 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17244 PyObject *resultobj = 0;
17245 wxCURHandler *result = 0 ;
17246
17247 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17248 {
17249 PyThreadState* __tstate = wxPyBeginAllowThreads();
17250 result = (wxCURHandler *)new wxCURHandler();
17251 wxPyEndAllowThreads(__tstate);
17252 if (PyErr_Occurred()) SWIG_fail;
17253 }
17254 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17255 return resultobj;
17256 fail:
17257 return NULL;
17258 }
17259
17260
17261 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17262 PyObject *obj;
17263 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17264 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17265 return SWIG_Py_Void();
17266 }
17267
17268 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17269 return SWIG_Python_InitShadowInstance(args);
17270 }
17271
17272 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17273 PyObject *resultobj = 0;
17274 wxANIHandler *result = 0 ;
17275
17276 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17277 {
17278 PyThreadState* __tstate = wxPyBeginAllowThreads();
17279 result = (wxANIHandler *)new wxANIHandler();
17280 wxPyEndAllowThreads(__tstate);
17281 if (PyErr_Occurred()) SWIG_fail;
17282 }
17283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17284 return resultobj;
17285 fail:
17286 return NULL;
17287 }
17288
17289
17290 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17291 PyObject *obj;
17292 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17293 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17294 return SWIG_Py_Void();
17295 }
17296
17297 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17298 return SWIG_Python_InitShadowInstance(args);
17299 }
17300
17301 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17302 PyObject *resultobj = 0;
17303 wxPNGHandler *result = 0 ;
17304
17305 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17306 {
17307 PyThreadState* __tstate = wxPyBeginAllowThreads();
17308 result = (wxPNGHandler *)new wxPNGHandler();
17309 wxPyEndAllowThreads(__tstate);
17310 if (PyErr_Occurred()) SWIG_fail;
17311 }
17312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17313 return resultobj;
17314 fail:
17315 return NULL;
17316 }
17317
17318
17319 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17320 PyObject *obj;
17321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17322 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17323 return SWIG_Py_Void();
17324 }
17325
17326 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17327 return SWIG_Python_InitShadowInstance(args);
17328 }
17329
17330 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17331 PyObject *resultobj = 0;
17332 wxGIFHandler *result = 0 ;
17333
17334 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17335 {
17336 PyThreadState* __tstate = wxPyBeginAllowThreads();
17337 result = (wxGIFHandler *)new wxGIFHandler();
17338 wxPyEndAllowThreads(__tstate);
17339 if (PyErr_Occurred()) SWIG_fail;
17340 }
17341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17342 return resultobj;
17343 fail:
17344 return NULL;
17345 }
17346
17347
17348 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17349 PyObject *obj;
17350 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17351 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17352 return SWIG_Py_Void();
17353 }
17354
17355 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17356 return SWIG_Python_InitShadowInstance(args);
17357 }
17358
17359 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17360 PyObject *resultobj = 0;
17361 wxPCXHandler *result = 0 ;
17362
17363 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17364 {
17365 PyThreadState* __tstate = wxPyBeginAllowThreads();
17366 result = (wxPCXHandler *)new wxPCXHandler();
17367 wxPyEndAllowThreads(__tstate);
17368 if (PyErr_Occurred()) SWIG_fail;
17369 }
17370 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17371 return resultobj;
17372 fail:
17373 return NULL;
17374 }
17375
17376
17377 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17378 PyObject *obj;
17379 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17380 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17381 return SWIG_Py_Void();
17382 }
17383
17384 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17385 return SWIG_Python_InitShadowInstance(args);
17386 }
17387
17388 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17389 PyObject *resultobj = 0;
17390 wxJPEGHandler *result = 0 ;
17391
17392 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17393 {
17394 PyThreadState* __tstate = wxPyBeginAllowThreads();
17395 result = (wxJPEGHandler *)new wxJPEGHandler();
17396 wxPyEndAllowThreads(__tstate);
17397 if (PyErr_Occurred()) SWIG_fail;
17398 }
17399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17400 return resultobj;
17401 fail:
17402 return NULL;
17403 }
17404
17405
17406 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17407 PyObject *obj;
17408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17409 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17410 return SWIG_Py_Void();
17411 }
17412
17413 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17414 return SWIG_Python_InitShadowInstance(args);
17415 }
17416
17417 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17418 PyObject *resultobj = 0;
17419 wxPNMHandler *result = 0 ;
17420
17421 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17422 {
17423 PyThreadState* __tstate = wxPyBeginAllowThreads();
17424 result = (wxPNMHandler *)new wxPNMHandler();
17425 wxPyEndAllowThreads(__tstate);
17426 if (PyErr_Occurred()) SWIG_fail;
17427 }
17428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17429 return resultobj;
17430 fail:
17431 return NULL;
17432 }
17433
17434
17435 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17436 PyObject *obj;
17437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17438 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17439 return SWIG_Py_Void();
17440 }
17441
17442 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17443 return SWIG_Python_InitShadowInstance(args);
17444 }
17445
17446 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17447 PyObject *resultobj = 0;
17448 wxXPMHandler *result = 0 ;
17449
17450 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17451 {
17452 PyThreadState* __tstate = wxPyBeginAllowThreads();
17453 result = (wxXPMHandler *)new wxXPMHandler();
17454 wxPyEndAllowThreads(__tstate);
17455 if (PyErr_Occurred()) SWIG_fail;
17456 }
17457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17458 return resultobj;
17459 fail:
17460 return NULL;
17461 }
17462
17463
17464 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17465 PyObject *obj;
17466 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17467 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17468 return SWIG_Py_Void();
17469 }
17470
17471 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17472 return SWIG_Python_InitShadowInstance(args);
17473 }
17474
17475 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17476 PyObject *resultobj = 0;
17477 wxTIFFHandler *result = 0 ;
17478
17479 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17480 {
17481 PyThreadState* __tstate = wxPyBeginAllowThreads();
17482 result = (wxTIFFHandler *)new wxTIFFHandler();
17483 wxPyEndAllowThreads(__tstate);
17484 if (PyErr_Occurred()) SWIG_fail;
17485 }
17486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17487 return resultobj;
17488 fail:
17489 return NULL;
17490 }
17491
17492
17493 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17494 PyObject *obj;
17495 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17496 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17497 return SWIG_Py_Void();
17498 }
17499
17500 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17501 return SWIG_Python_InitShadowInstance(args);
17502 }
17503
17504 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17505 PyObject *resultobj = 0;
17506 wxImage *arg1 = 0 ;
17507 wxImage *arg2 = 0 ;
17508 int arg3 = (int) 236 ;
17509 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17510 bool result;
17511 void *argp1 = 0 ;
17512 int res1 = 0 ;
17513 void *argp2 = 0 ;
17514 int res2 = 0 ;
17515 int val3 ;
17516 int ecode3 = 0 ;
17517 int val4 ;
17518 int ecode4 = 0 ;
17519 PyObject * obj0 = 0 ;
17520 PyObject * obj1 = 0 ;
17521 PyObject * obj2 = 0 ;
17522 PyObject * obj3 = 0 ;
17523 char * kwnames[] = {
17524 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17525 };
17526
17527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17528 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17529 if (!SWIG_IsOK(res1)) {
17530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17531 }
17532 if (!argp1) {
17533 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17534 }
17535 arg1 = reinterpret_cast< wxImage * >(argp1);
17536 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17537 if (!SWIG_IsOK(res2)) {
17538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17539 }
17540 if (!argp2) {
17541 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17542 }
17543 arg2 = reinterpret_cast< wxImage * >(argp2);
17544 if (obj2) {
17545 ecode3 = SWIG_AsVal_int(obj2, &val3);
17546 if (!SWIG_IsOK(ecode3)) {
17547 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17548 }
17549 arg3 = static_cast< int >(val3);
17550 }
17551 if (obj3) {
17552 ecode4 = SWIG_AsVal_int(obj3, &val4);
17553 if (!SWIG_IsOK(ecode4)) {
17554 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17555 }
17556 arg4 = static_cast< int >(val4);
17557 }
17558 {
17559 PyThreadState* __tstate = wxPyBeginAllowThreads();
17560 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17561 wxPyEndAllowThreads(__tstate);
17562 if (PyErr_Occurred()) SWIG_fail;
17563 }
17564 {
17565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17566 }
17567 return resultobj;
17568 fail:
17569 return NULL;
17570 }
17571
17572
17573 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17574 PyObject *obj;
17575 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17576 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17577 return SWIG_Py_Void();
17578 }
17579
17580 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17581 PyObject *resultobj = 0;
17582 wxEvtHandler *result = 0 ;
17583
17584 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17585 {
17586 PyThreadState* __tstate = wxPyBeginAllowThreads();
17587 result = (wxEvtHandler *)new wxEvtHandler();
17588 wxPyEndAllowThreads(__tstate);
17589 if (PyErr_Occurred()) SWIG_fail;
17590 }
17591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17592 return resultobj;
17593 fail:
17594 return NULL;
17595 }
17596
17597
17598 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17599 PyObject *resultobj = 0;
17600 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17601 wxEvtHandler *result = 0 ;
17602 void *argp1 = 0 ;
17603 int res1 = 0 ;
17604 PyObject *swig_obj[1] ;
17605
17606 if (!args) SWIG_fail;
17607 swig_obj[0] = args;
17608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17609 if (!SWIG_IsOK(res1)) {
17610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17611 }
17612 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17613 {
17614 PyThreadState* __tstate = wxPyBeginAllowThreads();
17615 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17616 wxPyEndAllowThreads(__tstate);
17617 if (PyErr_Occurred()) SWIG_fail;
17618 }
17619 {
17620 resultobj = wxPyMake_wxObject(result, 0);
17621 }
17622 return resultobj;
17623 fail:
17624 return NULL;
17625 }
17626
17627
17628 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17629 PyObject *resultobj = 0;
17630 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17631 wxEvtHandler *result = 0 ;
17632 void *argp1 = 0 ;
17633 int res1 = 0 ;
17634 PyObject *swig_obj[1] ;
17635
17636 if (!args) SWIG_fail;
17637 swig_obj[0] = args;
17638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17639 if (!SWIG_IsOK(res1)) {
17640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17641 }
17642 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17643 {
17644 PyThreadState* __tstate = wxPyBeginAllowThreads();
17645 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17646 wxPyEndAllowThreads(__tstate);
17647 if (PyErr_Occurred()) SWIG_fail;
17648 }
17649 {
17650 resultobj = wxPyMake_wxObject(result, 0);
17651 }
17652 return resultobj;
17653 fail:
17654 return NULL;
17655 }
17656
17657
17658 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17659 PyObject *resultobj = 0;
17660 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17661 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17662 void *argp1 = 0 ;
17663 int res1 = 0 ;
17664 void *argp2 = 0 ;
17665 int res2 = 0 ;
17666 PyObject * obj0 = 0 ;
17667 PyObject * obj1 = 0 ;
17668 char * kwnames[] = {
17669 (char *) "self",(char *) "handler", NULL
17670 };
17671
17672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17674 if (!SWIG_IsOK(res1)) {
17675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17676 }
17677 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17678 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17679 if (!SWIG_IsOK(res2)) {
17680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17681 }
17682 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17683 {
17684 PyThreadState* __tstate = wxPyBeginAllowThreads();
17685 (arg1)->SetNextHandler(arg2);
17686 wxPyEndAllowThreads(__tstate);
17687 if (PyErr_Occurred()) SWIG_fail;
17688 }
17689 resultobj = SWIG_Py_Void();
17690 return resultobj;
17691 fail:
17692 return NULL;
17693 }
17694
17695
17696 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17697 PyObject *resultobj = 0;
17698 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17699 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17700 void *argp1 = 0 ;
17701 int res1 = 0 ;
17702 void *argp2 = 0 ;
17703 int res2 = 0 ;
17704 PyObject * obj0 = 0 ;
17705 PyObject * obj1 = 0 ;
17706 char * kwnames[] = {
17707 (char *) "self",(char *) "handler", NULL
17708 };
17709
17710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17712 if (!SWIG_IsOK(res1)) {
17713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17714 }
17715 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17716 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17717 if (!SWIG_IsOK(res2)) {
17718 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17719 }
17720 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17721 {
17722 PyThreadState* __tstate = wxPyBeginAllowThreads();
17723 (arg1)->SetPreviousHandler(arg2);
17724 wxPyEndAllowThreads(__tstate);
17725 if (PyErr_Occurred()) SWIG_fail;
17726 }
17727 resultobj = SWIG_Py_Void();
17728 return resultobj;
17729 fail:
17730 return NULL;
17731 }
17732
17733
17734 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17735 PyObject *resultobj = 0;
17736 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17737 bool result;
17738 void *argp1 = 0 ;
17739 int res1 = 0 ;
17740 PyObject *swig_obj[1] ;
17741
17742 if (!args) SWIG_fail;
17743 swig_obj[0] = args;
17744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17745 if (!SWIG_IsOK(res1)) {
17746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17747 }
17748 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17749 {
17750 PyThreadState* __tstate = wxPyBeginAllowThreads();
17751 result = (bool)(arg1)->GetEvtHandlerEnabled();
17752 wxPyEndAllowThreads(__tstate);
17753 if (PyErr_Occurred()) SWIG_fail;
17754 }
17755 {
17756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17757 }
17758 return resultobj;
17759 fail:
17760 return NULL;
17761 }
17762
17763
17764 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17765 PyObject *resultobj = 0;
17766 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17767 bool arg2 ;
17768 void *argp1 = 0 ;
17769 int res1 = 0 ;
17770 bool val2 ;
17771 int ecode2 = 0 ;
17772 PyObject * obj0 = 0 ;
17773 PyObject * obj1 = 0 ;
17774 char * kwnames[] = {
17775 (char *) "self",(char *) "enabled", NULL
17776 };
17777
17778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17780 if (!SWIG_IsOK(res1)) {
17781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17782 }
17783 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17784 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17785 if (!SWIG_IsOK(ecode2)) {
17786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17787 }
17788 arg2 = static_cast< bool >(val2);
17789 {
17790 PyThreadState* __tstate = wxPyBeginAllowThreads();
17791 (arg1)->SetEvtHandlerEnabled(arg2);
17792 wxPyEndAllowThreads(__tstate);
17793 if (PyErr_Occurred()) SWIG_fail;
17794 }
17795 resultobj = SWIG_Py_Void();
17796 return resultobj;
17797 fail:
17798 return NULL;
17799 }
17800
17801
17802 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17803 PyObject *resultobj = 0;
17804 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17805 wxEvent *arg2 = 0 ;
17806 bool result;
17807 void *argp1 = 0 ;
17808 int res1 = 0 ;
17809 void *argp2 = 0 ;
17810 int res2 = 0 ;
17811 PyObject * obj0 = 0 ;
17812 PyObject * obj1 = 0 ;
17813 char * kwnames[] = {
17814 (char *) "self",(char *) "event", NULL
17815 };
17816
17817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17819 if (!SWIG_IsOK(res1)) {
17820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17821 }
17822 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17823 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17824 if (!SWIG_IsOK(res2)) {
17825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17826 }
17827 if (!argp2) {
17828 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17829 }
17830 arg2 = reinterpret_cast< wxEvent * >(argp2);
17831 {
17832 PyThreadState* __tstate = wxPyBeginAllowThreads();
17833 result = (bool)(arg1)->ProcessEvent(*arg2);
17834 wxPyEndAllowThreads(__tstate);
17835 if (PyErr_Occurred()) SWIG_fail;
17836 }
17837 {
17838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17839 }
17840 return resultobj;
17841 fail:
17842 return NULL;
17843 }
17844
17845
17846 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17847 PyObject *resultobj = 0;
17848 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17849 wxEvent *arg2 = 0 ;
17850 void *argp1 = 0 ;
17851 int res1 = 0 ;
17852 void *argp2 = 0 ;
17853 int res2 = 0 ;
17854 PyObject * obj0 = 0 ;
17855 PyObject * obj1 = 0 ;
17856 char * kwnames[] = {
17857 (char *) "self",(char *) "event", NULL
17858 };
17859
17860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17862 if (!SWIG_IsOK(res1)) {
17863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17864 }
17865 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17866 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17867 if (!SWIG_IsOK(res2)) {
17868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17869 }
17870 if (!argp2) {
17871 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17872 }
17873 arg2 = reinterpret_cast< wxEvent * >(argp2);
17874 {
17875 PyThreadState* __tstate = wxPyBeginAllowThreads();
17876 (arg1)->AddPendingEvent(*arg2);
17877 wxPyEndAllowThreads(__tstate);
17878 if (PyErr_Occurred()) SWIG_fail;
17879 }
17880 resultobj = SWIG_Py_Void();
17881 return resultobj;
17882 fail:
17883 return NULL;
17884 }
17885
17886
17887 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17888 PyObject *resultobj = 0;
17889 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17890 void *argp1 = 0 ;
17891 int res1 = 0 ;
17892 PyObject *swig_obj[1] ;
17893
17894 if (!args) SWIG_fail;
17895 swig_obj[0] = args;
17896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17897 if (!SWIG_IsOK(res1)) {
17898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17899 }
17900 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17901 {
17902 PyThreadState* __tstate = wxPyBeginAllowThreads();
17903 (arg1)->ProcessPendingEvents();
17904 wxPyEndAllowThreads(__tstate);
17905 if (PyErr_Occurred()) SWIG_fail;
17906 }
17907 resultobj = SWIG_Py_Void();
17908 return resultobj;
17909 fail:
17910 return NULL;
17911 }
17912
17913
17914 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17915 PyObject *resultobj = 0;
17916 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17917 int arg2 ;
17918 int arg3 ;
17919 int arg4 ;
17920 PyObject *arg5 = (PyObject *) 0 ;
17921 void *argp1 = 0 ;
17922 int res1 = 0 ;
17923 int val2 ;
17924 int ecode2 = 0 ;
17925 int val3 ;
17926 int ecode3 = 0 ;
17927 int val4 ;
17928 int ecode4 = 0 ;
17929 PyObject * obj0 = 0 ;
17930 PyObject * obj1 = 0 ;
17931 PyObject * obj2 = 0 ;
17932 PyObject * obj3 = 0 ;
17933 PyObject * obj4 = 0 ;
17934 char * kwnames[] = {
17935 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17936 };
17937
17938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17940 if (!SWIG_IsOK(res1)) {
17941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17942 }
17943 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17944 ecode2 = SWIG_AsVal_int(obj1, &val2);
17945 if (!SWIG_IsOK(ecode2)) {
17946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17947 }
17948 arg2 = static_cast< int >(val2);
17949 ecode3 = SWIG_AsVal_int(obj2, &val3);
17950 if (!SWIG_IsOK(ecode3)) {
17951 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17952 }
17953 arg3 = static_cast< int >(val3);
17954 ecode4 = SWIG_AsVal_int(obj3, &val4);
17955 if (!SWIG_IsOK(ecode4)) {
17956 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17957 }
17958 arg4 = static_cast< int >(val4);
17959 arg5 = obj4;
17960 {
17961 PyThreadState* __tstate = wxPyBeginAllowThreads();
17962 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17963 wxPyEndAllowThreads(__tstate);
17964 if (PyErr_Occurred()) SWIG_fail;
17965 }
17966 resultobj = SWIG_Py_Void();
17967 return resultobj;
17968 fail:
17969 return NULL;
17970 }
17971
17972
17973 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17974 PyObject *resultobj = 0;
17975 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17976 int arg2 ;
17977 int arg3 = (int) -1 ;
17978 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17979 bool result;
17980 void *argp1 = 0 ;
17981 int res1 = 0 ;
17982 int val2 ;
17983 int ecode2 = 0 ;
17984 int val3 ;
17985 int ecode3 = 0 ;
17986 int val4 ;
17987 int ecode4 = 0 ;
17988 PyObject * obj0 = 0 ;
17989 PyObject * obj1 = 0 ;
17990 PyObject * obj2 = 0 ;
17991 PyObject * obj3 = 0 ;
17992 char * kwnames[] = {
17993 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17994 };
17995
17996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17998 if (!SWIG_IsOK(res1)) {
17999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18000 }
18001 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18002 ecode2 = SWIG_AsVal_int(obj1, &val2);
18003 if (!SWIG_IsOK(ecode2)) {
18004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18005 }
18006 arg2 = static_cast< int >(val2);
18007 if (obj2) {
18008 ecode3 = SWIG_AsVal_int(obj2, &val3);
18009 if (!SWIG_IsOK(ecode3)) {
18010 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18011 }
18012 arg3 = static_cast< int >(val3);
18013 }
18014 if (obj3) {
18015 ecode4 = SWIG_AsVal_int(obj3, &val4);
18016 if (!SWIG_IsOK(ecode4)) {
18017 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18018 }
18019 arg4 = static_cast< wxEventType >(val4);
18020 }
18021 {
18022 PyThreadState* __tstate = wxPyBeginAllowThreads();
18023 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18024 wxPyEndAllowThreads(__tstate);
18025 if (PyErr_Occurred()) SWIG_fail;
18026 }
18027 {
18028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18029 }
18030 return resultobj;
18031 fail:
18032 return NULL;
18033 }
18034
18035
18036 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18037 PyObject *resultobj = 0;
18038 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18039 PyObject *arg2 = (PyObject *) 0 ;
18040 bool arg3 = (bool) true ;
18041 void *argp1 = 0 ;
18042 int res1 = 0 ;
18043 bool val3 ;
18044 int ecode3 = 0 ;
18045 PyObject * obj0 = 0 ;
18046 PyObject * obj1 = 0 ;
18047 PyObject * obj2 = 0 ;
18048 char * kwnames[] = {
18049 (char *) "self",(char *) "_self",(char *) "incref", NULL
18050 };
18051
18052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18054 if (!SWIG_IsOK(res1)) {
18055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18056 }
18057 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18058 arg2 = obj1;
18059 if (obj2) {
18060 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18061 if (!SWIG_IsOK(ecode3)) {
18062 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18063 }
18064 arg3 = static_cast< bool >(val3);
18065 }
18066 {
18067 PyThreadState* __tstate = wxPyBeginAllowThreads();
18068 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18069 wxPyEndAllowThreads(__tstate);
18070 if (PyErr_Occurred()) SWIG_fail;
18071 }
18072 resultobj = SWIG_Py_Void();
18073 return resultobj;
18074 fail:
18075 return NULL;
18076 }
18077
18078
18079 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18080 PyObject *obj;
18081 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18082 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18083 return SWIG_Py_Void();
18084 }
18085
18086 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18087 return SWIG_Python_InitShadowInstance(args);
18088 }
18089
18090 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18091 PyObject *resultobj = 0;
18092 wxEventType result;
18093
18094 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18095 {
18096 PyThreadState* __tstate = wxPyBeginAllowThreads();
18097 result = (wxEventType)wxNewEventType();
18098 wxPyEndAllowThreads(__tstate);
18099 if (PyErr_Occurred()) SWIG_fail;
18100 }
18101 resultobj = SWIG_From_int(static_cast< int >(result));
18102 return resultobj;
18103 fail:
18104 return NULL;
18105 }
18106
18107
18108 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18109 PyObject *resultobj = 0;
18110 wxEvent *arg1 = (wxEvent *) 0 ;
18111 void *argp1 = 0 ;
18112 int res1 = 0 ;
18113 PyObject *swig_obj[1] ;
18114
18115 if (!args) SWIG_fail;
18116 swig_obj[0] = args;
18117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18118 if (!SWIG_IsOK(res1)) {
18119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18120 }
18121 arg1 = reinterpret_cast< wxEvent * >(argp1);
18122 {
18123 PyThreadState* __tstate = wxPyBeginAllowThreads();
18124 delete arg1;
18125
18126 wxPyEndAllowThreads(__tstate);
18127 if (PyErr_Occurred()) SWIG_fail;
18128 }
18129 resultobj = SWIG_Py_Void();
18130 return resultobj;
18131 fail:
18132 return NULL;
18133 }
18134
18135
18136 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18137 PyObject *resultobj = 0;
18138 wxEvent *arg1 = (wxEvent *) 0 ;
18139 wxEventType arg2 ;
18140 void *argp1 = 0 ;
18141 int res1 = 0 ;
18142 int val2 ;
18143 int ecode2 = 0 ;
18144 PyObject * obj0 = 0 ;
18145 PyObject * obj1 = 0 ;
18146 char * kwnames[] = {
18147 (char *) "self",(char *) "typ", NULL
18148 };
18149
18150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18152 if (!SWIG_IsOK(res1)) {
18153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18154 }
18155 arg1 = reinterpret_cast< wxEvent * >(argp1);
18156 ecode2 = SWIG_AsVal_int(obj1, &val2);
18157 if (!SWIG_IsOK(ecode2)) {
18158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18159 }
18160 arg2 = static_cast< wxEventType >(val2);
18161 {
18162 PyThreadState* __tstate = wxPyBeginAllowThreads();
18163 (arg1)->SetEventType(arg2);
18164 wxPyEndAllowThreads(__tstate);
18165 if (PyErr_Occurred()) SWIG_fail;
18166 }
18167 resultobj = SWIG_Py_Void();
18168 return resultobj;
18169 fail:
18170 return NULL;
18171 }
18172
18173
18174 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18175 PyObject *resultobj = 0;
18176 wxEvent *arg1 = (wxEvent *) 0 ;
18177 wxEventType result;
18178 void *argp1 = 0 ;
18179 int res1 = 0 ;
18180 PyObject *swig_obj[1] ;
18181
18182 if (!args) SWIG_fail;
18183 swig_obj[0] = args;
18184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18185 if (!SWIG_IsOK(res1)) {
18186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18187 }
18188 arg1 = reinterpret_cast< wxEvent * >(argp1);
18189 {
18190 PyThreadState* __tstate = wxPyBeginAllowThreads();
18191 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18192 wxPyEndAllowThreads(__tstate);
18193 if (PyErr_Occurred()) SWIG_fail;
18194 }
18195 resultobj = SWIG_From_int(static_cast< int >(result));
18196 return resultobj;
18197 fail:
18198 return NULL;
18199 }
18200
18201
18202 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18203 PyObject *resultobj = 0;
18204 wxEvent *arg1 = (wxEvent *) 0 ;
18205 wxObject *result = 0 ;
18206 void *argp1 = 0 ;
18207 int res1 = 0 ;
18208 PyObject *swig_obj[1] ;
18209
18210 if (!args) SWIG_fail;
18211 swig_obj[0] = args;
18212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18213 if (!SWIG_IsOK(res1)) {
18214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18215 }
18216 arg1 = reinterpret_cast< wxEvent * >(argp1);
18217 {
18218 PyThreadState* __tstate = wxPyBeginAllowThreads();
18219 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18220 wxPyEndAllowThreads(__tstate);
18221 if (PyErr_Occurred()) SWIG_fail;
18222 }
18223 {
18224 resultobj = wxPyMake_wxObject(result, (bool)0);
18225 }
18226 return resultobj;
18227 fail:
18228 return NULL;
18229 }
18230
18231
18232 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18233 PyObject *resultobj = 0;
18234 wxEvent *arg1 = (wxEvent *) 0 ;
18235 wxObject *arg2 = (wxObject *) 0 ;
18236 void *argp1 = 0 ;
18237 int res1 = 0 ;
18238 void *argp2 = 0 ;
18239 int res2 = 0 ;
18240 PyObject * obj0 = 0 ;
18241 PyObject * obj1 = 0 ;
18242 char * kwnames[] = {
18243 (char *) "self",(char *) "obj", NULL
18244 };
18245
18246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18248 if (!SWIG_IsOK(res1)) {
18249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18250 }
18251 arg1 = reinterpret_cast< wxEvent * >(argp1);
18252 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18253 if (!SWIG_IsOK(res2)) {
18254 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18255 }
18256 arg2 = reinterpret_cast< wxObject * >(argp2);
18257 {
18258 PyThreadState* __tstate = wxPyBeginAllowThreads();
18259 (arg1)->SetEventObject(arg2);
18260 wxPyEndAllowThreads(__tstate);
18261 if (PyErr_Occurred()) SWIG_fail;
18262 }
18263 resultobj = SWIG_Py_Void();
18264 return resultobj;
18265 fail:
18266 return NULL;
18267 }
18268
18269
18270 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18271 PyObject *resultobj = 0;
18272 wxEvent *arg1 = (wxEvent *) 0 ;
18273 long result;
18274 void *argp1 = 0 ;
18275 int res1 = 0 ;
18276 PyObject *swig_obj[1] ;
18277
18278 if (!args) SWIG_fail;
18279 swig_obj[0] = args;
18280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18281 if (!SWIG_IsOK(res1)) {
18282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18283 }
18284 arg1 = reinterpret_cast< wxEvent * >(argp1);
18285 {
18286 PyThreadState* __tstate = wxPyBeginAllowThreads();
18287 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18288 wxPyEndAllowThreads(__tstate);
18289 if (PyErr_Occurred()) SWIG_fail;
18290 }
18291 resultobj = SWIG_From_long(static_cast< long >(result));
18292 return resultobj;
18293 fail:
18294 return NULL;
18295 }
18296
18297
18298 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18299 PyObject *resultobj = 0;
18300 wxEvent *arg1 = (wxEvent *) 0 ;
18301 long arg2 = (long) 0 ;
18302 void *argp1 = 0 ;
18303 int res1 = 0 ;
18304 long val2 ;
18305 int ecode2 = 0 ;
18306 PyObject * obj0 = 0 ;
18307 PyObject * obj1 = 0 ;
18308 char * kwnames[] = {
18309 (char *) "self",(char *) "ts", NULL
18310 };
18311
18312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18314 if (!SWIG_IsOK(res1)) {
18315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18316 }
18317 arg1 = reinterpret_cast< wxEvent * >(argp1);
18318 if (obj1) {
18319 ecode2 = SWIG_AsVal_long(obj1, &val2);
18320 if (!SWIG_IsOK(ecode2)) {
18321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18322 }
18323 arg2 = static_cast< long >(val2);
18324 }
18325 {
18326 PyThreadState* __tstate = wxPyBeginAllowThreads();
18327 (arg1)->SetTimestamp(arg2);
18328 wxPyEndAllowThreads(__tstate);
18329 if (PyErr_Occurred()) SWIG_fail;
18330 }
18331 resultobj = SWIG_Py_Void();
18332 return resultobj;
18333 fail:
18334 return NULL;
18335 }
18336
18337
18338 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18339 PyObject *resultobj = 0;
18340 wxEvent *arg1 = (wxEvent *) 0 ;
18341 int result;
18342 void *argp1 = 0 ;
18343 int res1 = 0 ;
18344 PyObject *swig_obj[1] ;
18345
18346 if (!args) SWIG_fail;
18347 swig_obj[0] = args;
18348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18349 if (!SWIG_IsOK(res1)) {
18350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18351 }
18352 arg1 = reinterpret_cast< wxEvent * >(argp1);
18353 {
18354 PyThreadState* __tstate = wxPyBeginAllowThreads();
18355 result = (int)((wxEvent const *)arg1)->GetId();
18356 wxPyEndAllowThreads(__tstate);
18357 if (PyErr_Occurred()) SWIG_fail;
18358 }
18359 resultobj = SWIG_From_int(static_cast< int >(result));
18360 return resultobj;
18361 fail:
18362 return NULL;
18363 }
18364
18365
18366 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18367 PyObject *resultobj = 0;
18368 wxEvent *arg1 = (wxEvent *) 0 ;
18369 int arg2 ;
18370 void *argp1 = 0 ;
18371 int res1 = 0 ;
18372 int val2 ;
18373 int ecode2 = 0 ;
18374 PyObject * obj0 = 0 ;
18375 PyObject * obj1 = 0 ;
18376 char * kwnames[] = {
18377 (char *) "self",(char *) "Id", NULL
18378 };
18379
18380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18382 if (!SWIG_IsOK(res1)) {
18383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18384 }
18385 arg1 = reinterpret_cast< wxEvent * >(argp1);
18386 ecode2 = SWIG_AsVal_int(obj1, &val2);
18387 if (!SWIG_IsOK(ecode2)) {
18388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18389 }
18390 arg2 = static_cast< int >(val2);
18391 {
18392 PyThreadState* __tstate = wxPyBeginAllowThreads();
18393 (arg1)->SetId(arg2);
18394 wxPyEndAllowThreads(__tstate);
18395 if (PyErr_Occurred()) SWIG_fail;
18396 }
18397 resultobj = SWIG_Py_Void();
18398 return resultobj;
18399 fail:
18400 return NULL;
18401 }
18402
18403
18404 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18405 PyObject *resultobj = 0;
18406 wxEvent *arg1 = (wxEvent *) 0 ;
18407 bool result;
18408 void *argp1 = 0 ;
18409 int res1 = 0 ;
18410 PyObject *swig_obj[1] ;
18411
18412 if (!args) SWIG_fail;
18413 swig_obj[0] = args;
18414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18415 if (!SWIG_IsOK(res1)) {
18416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18417 }
18418 arg1 = reinterpret_cast< wxEvent * >(argp1);
18419 {
18420 PyThreadState* __tstate = wxPyBeginAllowThreads();
18421 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18422 wxPyEndAllowThreads(__tstate);
18423 if (PyErr_Occurred()) SWIG_fail;
18424 }
18425 {
18426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18427 }
18428 return resultobj;
18429 fail:
18430 return NULL;
18431 }
18432
18433
18434 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18435 PyObject *resultobj = 0;
18436 wxEvent *arg1 = (wxEvent *) 0 ;
18437 bool arg2 = (bool) true ;
18438 void *argp1 = 0 ;
18439 int res1 = 0 ;
18440 bool val2 ;
18441 int ecode2 = 0 ;
18442 PyObject * obj0 = 0 ;
18443 PyObject * obj1 = 0 ;
18444 char * kwnames[] = {
18445 (char *) "self",(char *) "skip", NULL
18446 };
18447
18448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18450 if (!SWIG_IsOK(res1)) {
18451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18452 }
18453 arg1 = reinterpret_cast< wxEvent * >(argp1);
18454 if (obj1) {
18455 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18456 if (!SWIG_IsOK(ecode2)) {
18457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18458 }
18459 arg2 = static_cast< bool >(val2);
18460 }
18461 {
18462 PyThreadState* __tstate = wxPyBeginAllowThreads();
18463 (arg1)->Skip(arg2);
18464 wxPyEndAllowThreads(__tstate);
18465 if (PyErr_Occurred()) SWIG_fail;
18466 }
18467 resultobj = SWIG_Py_Void();
18468 return resultobj;
18469 fail:
18470 return NULL;
18471 }
18472
18473
18474 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18475 PyObject *resultobj = 0;
18476 wxEvent *arg1 = (wxEvent *) 0 ;
18477 bool result;
18478 void *argp1 = 0 ;
18479 int res1 = 0 ;
18480 PyObject *swig_obj[1] ;
18481
18482 if (!args) SWIG_fail;
18483 swig_obj[0] = args;
18484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18485 if (!SWIG_IsOK(res1)) {
18486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18487 }
18488 arg1 = reinterpret_cast< wxEvent * >(argp1);
18489 {
18490 PyThreadState* __tstate = wxPyBeginAllowThreads();
18491 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18492 wxPyEndAllowThreads(__tstate);
18493 if (PyErr_Occurred()) SWIG_fail;
18494 }
18495 {
18496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18497 }
18498 return resultobj;
18499 fail:
18500 return NULL;
18501 }
18502
18503
18504 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18505 PyObject *resultobj = 0;
18506 wxEvent *arg1 = (wxEvent *) 0 ;
18507 bool result;
18508 void *argp1 = 0 ;
18509 int res1 = 0 ;
18510 PyObject *swig_obj[1] ;
18511
18512 if (!args) SWIG_fail;
18513 swig_obj[0] = args;
18514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18515 if (!SWIG_IsOK(res1)) {
18516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18517 }
18518 arg1 = reinterpret_cast< wxEvent * >(argp1);
18519 {
18520 PyThreadState* __tstate = wxPyBeginAllowThreads();
18521 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18522 wxPyEndAllowThreads(__tstate);
18523 if (PyErr_Occurred()) SWIG_fail;
18524 }
18525 {
18526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18527 }
18528 return resultobj;
18529 fail:
18530 return NULL;
18531 }
18532
18533
18534 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18535 PyObject *resultobj = 0;
18536 wxEvent *arg1 = (wxEvent *) 0 ;
18537 int result;
18538 void *argp1 = 0 ;
18539 int res1 = 0 ;
18540 PyObject *swig_obj[1] ;
18541
18542 if (!args) SWIG_fail;
18543 swig_obj[0] = args;
18544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18545 if (!SWIG_IsOK(res1)) {
18546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18547 }
18548 arg1 = reinterpret_cast< wxEvent * >(argp1);
18549 {
18550 PyThreadState* __tstate = wxPyBeginAllowThreads();
18551 result = (int)(arg1)->StopPropagation();
18552 wxPyEndAllowThreads(__tstate);
18553 if (PyErr_Occurred()) SWIG_fail;
18554 }
18555 resultobj = SWIG_From_int(static_cast< int >(result));
18556 return resultobj;
18557 fail:
18558 return NULL;
18559 }
18560
18561
18562 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18563 PyObject *resultobj = 0;
18564 wxEvent *arg1 = (wxEvent *) 0 ;
18565 int arg2 ;
18566 void *argp1 = 0 ;
18567 int res1 = 0 ;
18568 int val2 ;
18569 int ecode2 = 0 ;
18570 PyObject * obj0 = 0 ;
18571 PyObject * obj1 = 0 ;
18572 char * kwnames[] = {
18573 (char *) "self",(char *) "propagationLevel", NULL
18574 };
18575
18576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18578 if (!SWIG_IsOK(res1)) {
18579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18580 }
18581 arg1 = reinterpret_cast< wxEvent * >(argp1);
18582 ecode2 = SWIG_AsVal_int(obj1, &val2);
18583 if (!SWIG_IsOK(ecode2)) {
18584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18585 }
18586 arg2 = static_cast< int >(val2);
18587 {
18588 PyThreadState* __tstate = wxPyBeginAllowThreads();
18589 (arg1)->ResumePropagation(arg2);
18590 wxPyEndAllowThreads(__tstate);
18591 if (PyErr_Occurred()) SWIG_fail;
18592 }
18593 resultobj = SWIG_Py_Void();
18594 return resultobj;
18595 fail:
18596 return NULL;
18597 }
18598
18599
18600 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18601 PyObject *resultobj = 0;
18602 wxEvent *arg1 = (wxEvent *) 0 ;
18603 wxEvent *result = 0 ;
18604 void *argp1 = 0 ;
18605 int res1 = 0 ;
18606 PyObject *swig_obj[1] ;
18607
18608 if (!args) SWIG_fail;
18609 swig_obj[0] = args;
18610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18611 if (!SWIG_IsOK(res1)) {
18612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18613 }
18614 arg1 = reinterpret_cast< wxEvent * >(argp1);
18615 {
18616 PyThreadState* __tstate = wxPyBeginAllowThreads();
18617 result = (wxEvent *)(arg1)->Clone();
18618 wxPyEndAllowThreads(__tstate);
18619 if (PyErr_Occurred()) SWIG_fail;
18620 }
18621 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18622 return resultobj;
18623 fail:
18624 return NULL;
18625 }
18626
18627
18628 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18629 PyObject *obj;
18630 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18631 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18632 return SWIG_Py_Void();
18633 }
18634
18635 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18636 PyObject *resultobj = 0;
18637 wxEvent *arg1 = 0 ;
18638 wxPropagationDisabler *result = 0 ;
18639 void *argp1 = 0 ;
18640 int res1 = 0 ;
18641 PyObject * obj0 = 0 ;
18642 char * kwnames[] = {
18643 (char *) "event", NULL
18644 };
18645
18646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18647 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18648 if (!SWIG_IsOK(res1)) {
18649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18650 }
18651 if (!argp1) {
18652 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18653 }
18654 arg1 = reinterpret_cast< wxEvent * >(argp1);
18655 {
18656 PyThreadState* __tstate = wxPyBeginAllowThreads();
18657 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18658 wxPyEndAllowThreads(__tstate);
18659 if (PyErr_Occurred()) SWIG_fail;
18660 }
18661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18662 return resultobj;
18663 fail:
18664 return NULL;
18665 }
18666
18667
18668 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18669 PyObject *resultobj = 0;
18670 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18671 void *argp1 = 0 ;
18672 int res1 = 0 ;
18673 PyObject *swig_obj[1] ;
18674
18675 if (!args) SWIG_fail;
18676 swig_obj[0] = args;
18677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18678 if (!SWIG_IsOK(res1)) {
18679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18680 }
18681 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18682 {
18683 PyThreadState* __tstate = wxPyBeginAllowThreads();
18684 delete arg1;
18685
18686 wxPyEndAllowThreads(__tstate);
18687 if (PyErr_Occurred()) SWIG_fail;
18688 }
18689 resultobj = SWIG_Py_Void();
18690 return resultobj;
18691 fail:
18692 return NULL;
18693 }
18694
18695
18696 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18697 PyObject *obj;
18698 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18699 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18700 return SWIG_Py_Void();
18701 }
18702
18703 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18704 return SWIG_Python_InitShadowInstance(args);
18705 }
18706
18707 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18708 PyObject *resultobj = 0;
18709 wxEvent *arg1 = 0 ;
18710 wxPropagateOnce *result = 0 ;
18711 void *argp1 = 0 ;
18712 int res1 = 0 ;
18713 PyObject * obj0 = 0 ;
18714 char * kwnames[] = {
18715 (char *) "event", NULL
18716 };
18717
18718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18719 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18720 if (!SWIG_IsOK(res1)) {
18721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18722 }
18723 if (!argp1) {
18724 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18725 }
18726 arg1 = reinterpret_cast< wxEvent * >(argp1);
18727 {
18728 PyThreadState* __tstate = wxPyBeginAllowThreads();
18729 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18730 wxPyEndAllowThreads(__tstate);
18731 if (PyErr_Occurred()) SWIG_fail;
18732 }
18733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18734 return resultobj;
18735 fail:
18736 return NULL;
18737 }
18738
18739
18740 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18741 PyObject *resultobj = 0;
18742 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18743 void *argp1 = 0 ;
18744 int res1 = 0 ;
18745 PyObject *swig_obj[1] ;
18746
18747 if (!args) SWIG_fail;
18748 swig_obj[0] = args;
18749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18750 if (!SWIG_IsOK(res1)) {
18751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18752 }
18753 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18754 {
18755 PyThreadState* __tstate = wxPyBeginAllowThreads();
18756 delete arg1;
18757
18758 wxPyEndAllowThreads(__tstate);
18759 if (PyErr_Occurred()) SWIG_fail;
18760 }
18761 resultobj = SWIG_Py_Void();
18762 return resultobj;
18763 fail:
18764 return NULL;
18765 }
18766
18767
18768 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18769 PyObject *obj;
18770 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18771 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18772 return SWIG_Py_Void();
18773 }
18774
18775 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18776 return SWIG_Python_InitShadowInstance(args);
18777 }
18778
18779 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18780 PyObject *resultobj = 0;
18781 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18782 int arg2 = (int) 0 ;
18783 wxCommandEvent *result = 0 ;
18784 int val1 ;
18785 int ecode1 = 0 ;
18786 int val2 ;
18787 int ecode2 = 0 ;
18788 PyObject * obj0 = 0 ;
18789 PyObject * obj1 = 0 ;
18790 char * kwnames[] = {
18791 (char *) "commandType",(char *) "winid", NULL
18792 };
18793
18794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18795 if (obj0) {
18796 ecode1 = SWIG_AsVal_int(obj0, &val1);
18797 if (!SWIG_IsOK(ecode1)) {
18798 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18799 }
18800 arg1 = static_cast< wxEventType >(val1);
18801 }
18802 if (obj1) {
18803 ecode2 = SWIG_AsVal_int(obj1, &val2);
18804 if (!SWIG_IsOK(ecode2)) {
18805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18806 }
18807 arg2 = static_cast< int >(val2);
18808 }
18809 {
18810 PyThreadState* __tstate = wxPyBeginAllowThreads();
18811 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18812 wxPyEndAllowThreads(__tstate);
18813 if (PyErr_Occurred()) SWIG_fail;
18814 }
18815 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18816 return resultobj;
18817 fail:
18818 return NULL;
18819 }
18820
18821
18822 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18823 PyObject *resultobj = 0;
18824 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18825 int result;
18826 void *argp1 = 0 ;
18827 int res1 = 0 ;
18828 PyObject *swig_obj[1] ;
18829
18830 if (!args) SWIG_fail;
18831 swig_obj[0] = args;
18832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18833 if (!SWIG_IsOK(res1)) {
18834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18835 }
18836 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18837 {
18838 PyThreadState* __tstate = wxPyBeginAllowThreads();
18839 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18840 wxPyEndAllowThreads(__tstate);
18841 if (PyErr_Occurred()) SWIG_fail;
18842 }
18843 resultobj = SWIG_From_int(static_cast< int >(result));
18844 return resultobj;
18845 fail:
18846 return NULL;
18847 }
18848
18849
18850 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18851 PyObject *resultobj = 0;
18852 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18853 wxString *arg2 = 0 ;
18854 void *argp1 = 0 ;
18855 int res1 = 0 ;
18856 bool temp2 = false ;
18857 PyObject * obj0 = 0 ;
18858 PyObject * obj1 = 0 ;
18859 char * kwnames[] = {
18860 (char *) "self",(char *) "s", NULL
18861 };
18862
18863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18865 if (!SWIG_IsOK(res1)) {
18866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18867 }
18868 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18869 {
18870 arg2 = wxString_in_helper(obj1);
18871 if (arg2 == NULL) SWIG_fail;
18872 temp2 = true;
18873 }
18874 {
18875 PyThreadState* __tstate = wxPyBeginAllowThreads();
18876 (arg1)->SetString((wxString const &)*arg2);
18877 wxPyEndAllowThreads(__tstate);
18878 if (PyErr_Occurred()) SWIG_fail;
18879 }
18880 resultobj = SWIG_Py_Void();
18881 {
18882 if (temp2)
18883 delete arg2;
18884 }
18885 return resultobj;
18886 fail:
18887 {
18888 if (temp2)
18889 delete arg2;
18890 }
18891 return NULL;
18892 }
18893
18894
18895 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18896 PyObject *resultobj = 0;
18897 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18898 wxString result;
18899 void *argp1 = 0 ;
18900 int res1 = 0 ;
18901 PyObject *swig_obj[1] ;
18902
18903 if (!args) SWIG_fail;
18904 swig_obj[0] = args;
18905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18906 if (!SWIG_IsOK(res1)) {
18907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18908 }
18909 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18910 {
18911 PyThreadState* __tstate = wxPyBeginAllowThreads();
18912 result = ((wxCommandEvent const *)arg1)->GetString();
18913 wxPyEndAllowThreads(__tstate);
18914 if (PyErr_Occurred()) SWIG_fail;
18915 }
18916 {
18917 #if wxUSE_UNICODE
18918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18919 #else
18920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18921 #endif
18922 }
18923 return resultobj;
18924 fail:
18925 return NULL;
18926 }
18927
18928
18929 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18930 PyObject *resultobj = 0;
18931 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18932 bool result;
18933 void *argp1 = 0 ;
18934 int res1 = 0 ;
18935 PyObject *swig_obj[1] ;
18936
18937 if (!args) SWIG_fail;
18938 swig_obj[0] = args;
18939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18940 if (!SWIG_IsOK(res1)) {
18941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18942 }
18943 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18944 {
18945 PyThreadState* __tstate = wxPyBeginAllowThreads();
18946 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18947 wxPyEndAllowThreads(__tstate);
18948 if (PyErr_Occurred()) SWIG_fail;
18949 }
18950 {
18951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18952 }
18953 return resultobj;
18954 fail:
18955 return NULL;
18956 }
18957
18958
18959 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18960 PyObject *resultobj = 0;
18961 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18962 bool result;
18963 void *argp1 = 0 ;
18964 int res1 = 0 ;
18965 PyObject *swig_obj[1] ;
18966
18967 if (!args) SWIG_fail;
18968 swig_obj[0] = args;
18969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18970 if (!SWIG_IsOK(res1)) {
18971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18972 }
18973 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18974 {
18975 PyThreadState* __tstate = wxPyBeginAllowThreads();
18976 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18977 wxPyEndAllowThreads(__tstate);
18978 if (PyErr_Occurred()) SWIG_fail;
18979 }
18980 {
18981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18982 }
18983 return resultobj;
18984 fail:
18985 return NULL;
18986 }
18987
18988
18989 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18990 PyObject *resultobj = 0;
18991 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18992 long arg2 ;
18993 void *argp1 = 0 ;
18994 int res1 = 0 ;
18995 long val2 ;
18996 int ecode2 = 0 ;
18997 PyObject * obj0 = 0 ;
18998 PyObject * obj1 = 0 ;
18999 char * kwnames[] = {
19000 (char *) "self",(char *) "extraLong", NULL
19001 };
19002
19003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19005 if (!SWIG_IsOK(res1)) {
19006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19007 }
19008 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19009 ecode2 = SWIG_AsVal_long(obj1, &val2);
19010 if (!SWIG_IsOK(ecode2)) {
19011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19012 }
19013 arg2 = static_cast< long >(val2);
19014 {
19015 PyThreadState* __tstate = wxPyBeginAllowThreads();
19016 (arg1)->SetExtraLong(arg2);
19017 wxPyEndAllowThreads(__tstate);
19018 if (PyErr_Occurred()) SWIG_fail;
19019 }
19020 resultobj = SWIG_Py_Void();
19021 return resultobj;
19022 fail:
19023 return NULL;
19024 }
19025
19026
19027 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19028 PyObject *resultobj = 0;
19029 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19030 long result;
19031 void *argp1 = 0 ;
19032 int res1 = 0 ;
19033 PyObject *swig_obj[1] ;
19034
19035 if (!args) SWIG_fail;
19036 swig_obj[0] = args;
19037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19038 if (!SWIG_IsOK(res1)) {
19039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19040 }
19041 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19042 {
19043 PyThreadState* __tstate = wxPyBeginAllowThreads();
19044 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19045 wxPyEndAllowThreads(__tstate);
19046 if (PyErr_Occurred()) SWIG_fail;
19047 }
19048 resultobj = SWIG_From_long(static_cast< long >(result));
19049 return resultobj;
19050 fail:
19051 return NULL;
19052 }
19053
19054
19055 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19056 PyObject *resultobj = 0;
19057 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19058 int arg2 ;
19059 void *argp1 = 0 ;
19060 int res1 = 0 ;
19061 int val2 ;
19062 int ecode2 = 0 ;
19063 PyObject * obj0 = 0 ;
19064 PyObject * obj1 = 0 ;
19065 char * kwnames[] = {
19066 (char *) "self",(char *) "i", NULL
19067 };
19068
19069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19071 if (!SWIG_IsOK(res1)) {
19072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19073 }
19074 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19075 ecode2 = SWIG_AsVal_int(obj1, &val2);
19076 if (!SWIG_IsOK(ecode2)) {
19077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19078 }
19079 arg2 = static_cast< int >(val2);
19080 {
19081 PyThreadState* __tstate = wxPyBeginAllowThreads();
19082 (arg1)->SetInt(arg2);
19083 wxPyEndAllowThreads(__tstate);
19084 if (PyErr_Occurred()) SWIG_fail;
19085 }
19086 resultobj = SWIG_Py_Void();
19087 return resultobj;
19088 fail:
19089 return NULL;
19090 }
19091
19092
19093 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19094 PyObject *resultobj = 0;
19095 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19096 int result;
19097 void *argp1 = 0 ;
19098 int res1 = 0 ;
19099 PyObject *swig_obj[1] ;
19100
19101 if (!args) SWIG_fail;
19102 swig_obj[0] = args;
19103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19104 if (!SWIG_IsOK(res1)) {
19105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19106 }
19107 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19108 {
19109 PyThreadState* __tstate = wxPyBeginAllowThreads();
19110 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19111 wxPyEndAllowThreads(__tstate);
19112 if (PyErr_Occurred()) SWIG_fail;
19113 }
19114 resultobj = SWIG_From_int(static_cast< int >(result));
19115 return resultobj;
19116 fail:
19117 return NULL;
19118 }
19119
19120
19121 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19122 PyObject *resultobj = 0;
19123 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19124 PyObject *result = 0 ;
19125 void *argp1 = 0 ;
19126 int res1 = 0 ;
19127 PyObject *swig_obj[1] ;
19128
19129 if (!args) SWIG_fail;
19130 swig_obj[0] = args;
19131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19132 if (!SWIG_IsOK(res1)) {
19133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19134 }
19135 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19136 {
19137 PyThreadState* __tstate = wxPyBeginAllowThreads();
19138 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19139 wxPyEndAllowThreads(__tstate);
19140 if (PyErr_Occurred()) SWIG_fail;
19141 }
19142 resultobj = result;
19143 return resultobj;
19144 fail:
19145 return NULL;
19146 }
19147
19148
19149 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19150 PyObject *resultobj = 0;
19151 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19152 PyObject *arg2 = (PyObject *) 0 ;
19153 void *argp1 = 0 ;
19154 int res1 = 0 ;
19155 PyObject * obj0 = 0 ;
19156 PyObject * obj1 = 0 ;
19157 char * kwnames[] = {
19158 (char *) "self",(char *) "clientData", NULL
19159 };
19160
19161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19163 if (!SWIG_IsOK(res1)) {
19164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19165 }
19166 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19167 arg2 = obj1;
19168 {
19169 PyThreadState* __tstate = wxPyBeginAllowThreads();
19170 wxCommandEvent_SetClientData(arg1,arg2);
19171 wxPyEndAllowThreads(__tstate);
19172 if (PyErr_Occurred()) SWIG_fail;
19173 }
19174 resultobj = SWIG_Py_Void();
19175 return resultobj;
19176 fail:
19177 return NULL;
19178 }
19179
19180
19181 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19182 PyObject *resultobj = 0;
19183 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19184 wxEvent *result = 0 ;
19185 void *argp1 = 0 ;
19186 int res1 = 0 ;
19187 PyObject *swig_obj[1] ;
19188
19189 if (!args) SWIG_fail;
19190 swig_obj[0] = args;
19191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19192 if (!SWIG_IsOK(res1)) {
19193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19194 }
19195 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19196 {
19197 PyThreadState* __tstate = wxPyBeginAllowThreads();
19198 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19199 wxPyEndAllowThreads(__tstate);
19200 if (PyErr_Occurred()) SWIG_fail;
19201 }
19202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19203 return resultobj;
19204 fail:
19205 return NULL;
19206 }
19207
19208
19209 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19210 PyObject *obj;
19211 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19212 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19213 return SWIG_Py_Void();
19214 }
19215
19216 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19217 return SWIG_Python_InitShadowInstance(args);
19218 }
19219
19220 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19221 PyObject *resultobj = 0;
19222 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19223 int arg2 = (int) 0 ;
19224 wxNotifyEvent *result = 0 ;
19225 int val1 ;
19226 int ecode1 = 0 ;
19227 int val2 ;
19228 int ecode2 = 0 ;
19229 PyObject * obj0 = 0 ;
19230 PyObject * obj1 = 0 ;
19231 char * kwnames[] = {
19232 (char *) "commandType",(char *) "winid", NULL
19233 };
19234
19235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19236 if (obj0) {
19237 ecode1 = SWIG_AsVal_int(obj0, &val1);
19238 if (!SWIG_IsOK(ecode1)) {
19239 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19240 }
19241 arg1 = static_cast< wxEventType >(val1);
19242 }
19243 if (obj1) {
19244 ecode2 = SWIG_AsVal_int(obj1, &val2);
19245 if (!SWIG_IsOK(ecode2)) {
19246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19247 }
19248 arg2 = static_cast< int >(val2);
19249 }
19250 {
19251 PyThreadState* __tstate = wxPyBeginAllowThreads();
19252 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19253 wxPyEndAllowThreads(__tstate);
19254 if (PyErr_Occurred()) SWIG_fail;
19255 }
19256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19257 return resultobj;
19258 fail:
19259 return NULL;
19260 }
19261
19262
19263 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19264 PyObject *resultobj = 0;
19265 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19266 void *argp1 = 0 ;
19267 int res1 = 0 ;
19268 PyObject *swig_obj[1] ;
19269
19270 if (!args) SWIG_fail;
19271 swig_obj[0] = args;
19272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19273 if (!SWIG_IsOK(res1)) {
19274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19275 }
19276 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19277 {
19278 PyThreadState* __tstate = wxPyBeginAllowThreads();
19279 (arg1)->Veto();
19280 wxPyEndAllowThreads(__tstate);
19281 if (PyErr_Occurred()) SWIG_fail;
19282 }
19283 resultobj = SWIG_Py_Void();
19284 return resultobj;
19285 fail:
19286 return NULL;
19287 }
19288
19289
19290 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19291 PyObject *resultobj = 0;
19292 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19293 void *argp1 = 0 ;
19294 int res1 = 0 ;
19295 PyObject *swig_obj[1] ;
19296
19297 if (!args) SWIG_fail;
19298 swig_obj[0] = args;
19299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19300 if (!SWIG_IsOK(res1)) {
19301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19302 }
19303 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19304 {
19305 PyThreadState* __tstate = wxPyBeginAllowThreads();
19306 (arg1)->Allow();
19307 wxPyEndAllowThreads(__tstate);
19308 if (PyErr_Occurred()) SWIG_fail;
19309 }
19310 resultobj = SWIG_Py_Void();
19311 return resultobj;
19312 fail:
19313 return NULL;
19314 }
19315
19316
19317 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19318 PyObject *resultobj = 0;
19319 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19320 bool result;
19321 void *argp1 = 0 ;
19322 int res1 = 0 ;
19323 PyObject *swig_obj[1] ;
19324
19325 if (!args) SWIG_fail;
19326 swig_obj[0] = args;
19327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19328 if (!SWIG_IsOK(res1)) {
19329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19330 }
19331 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19332 {
19333 PyThreadState* __tstate = wxPyBeginAllowThreads();
19334 result = (bool)(arg1)->IsAllowed();
19335 wxPyEndAllowThreads(__tstate);
19336 if (PyErr_Occurred()) SWIG_fail;
19337 }
19338 {
19339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19340 }
19341 return resultobj;
19342 fail:
19343 return NULL;
19344 }
19345
19346
19347 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19348 PyObject *obj;
19349 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19350 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19351 return SWIG_Py_Void();
19352 }
19353
19354 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19355 return SWIG_Python_InitShadowInstance(args);
19356 }
19357
19358 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19359 PyObject *resultobj = 0;
19360 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19361 int arg2 = (int) 0 ;
19362 int arg3 = (int) 0 ;
19363 int arg4 = (int) 0 ;
19364 wxScrollEvent *result = 0 ;
19365 int val1 ;
19366 int ecode1 = 0 ;
19367 int val2 ;
19368 int ecode2 = 0 ;
19369 int val3 ;
19370 int ecode3 = 0 ;
19371 int val4 ;
19372 int ecode4 = 0 ;
19373 PyObject * obj0 = 0 ;
19374 PyObject * obj1 = 0 ;
19375 PyObject * obj2 = 0 ;
19376 PyObject * obj3 = 0 ;
19377 char * kwnames[] = {
19378 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19379 };
19380
19381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19382 if (obj0) {
19383 ecode1 = SWIG_AsVal_int(obj0, &val1);
19384 if (!SWIG_IsOK(ecode1)) {
19385 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19386 }
19387 arg1 = static_cast< wxEventType >(val1);
19388 }
19389 if (obj1) {
19390 ecode2 = SWIG_AsVal_int(obj1, &val2);
19391 if (!SWIG_IsOK(ecode2)) {
19392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19393 }
19394 arg2 = static_cast< int >(val2);
19395 }
19396 if (obj2) {
19397 ecode3 = SWIG_AsVal_int(obj2, &val3);
19398 if (!SWIG_IsOK(ecode3)) {
19399 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19400 }
19401 arg3 = static_cast< int >(val3);
19402 }
19403 if (obj3) {
19404 ecode4 = SWIG_AsVal_int(obj3, &val4);
19405 if (!SWIG_IsOK(ecode4)) {
19406 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19407 }
19408 arg4 = static_cast< int >(val4);
19409 }
19410 {
19411 PyThreadState* __tstate = wxPyBeginAllowThreads();
19412 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19413 wxPyEndAllowThreads(__tstate);
19414 if (PyErr_Occurred()) SWIG_fail;
19415 }
19416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19417 return resultobj;
19418 fail:
19419 return NULL;
19420 }
19421
19422
19423 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19424 PyObject *resultobj = 0;
19425 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19426 int result;
19427 void *argp1 = 0 ;
19428 int res1 = 0 ;
19429 PyObject *swig_obj[1] ;
19430
19431 if (!args) SWIG_fail;
19432 swig_obj[0] = args;
19433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19434 if (!SWIG_IsOK(res1)) {
19435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19436 }
19437 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19438 {
19439 PyThreadState* __tstate = wxPyBeginAllowThreads();
19440 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19441 wxPyEndAllowThreads(__tstate);
19442 if (PyErr_Occurred()) SWIG_fail;
19443 }
19444 resultobj = SWIG_From_int(static_cast< int >(result));
19445 return resultobj;
19446 fail:
19447 return NULL;
19448 }
19449
19450
19451 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19452 PyObject *resultobj = 0;
19453 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19454 int result;
19455 void *argp1 = 0 ;
19456 int res1 = 0 ;
19457 PyObject *swig_obj[1] ;
19458
19459 if (!args) SWIG_fail;
19460 swig_obj[0] = args;
19461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19462 if (!SWIG_IsOK(res1)) {
19463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19464 }
19465 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19466 {
19467 PyThreadState* __tstate = wxPyBeginAllowThreads();
19468 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19469 wxPyEndAllowThreads(__tstate);
19470 if (PyErr_Occurred()) SWIG_fail;
19471 }
19472 resultobj = SWIG_From_int(static_cast< int >(result));
19473 return resultobj;
19474 fail:
19475 return NULL;
19476 }
19477
19478
19479 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19480 PyObject *resultobj = 0;
19481 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19482 int arg2 ;
19483 void *argp1 = 0 ;
19484 int res1 = 0 ;
19485 int val2 ;
19486 int ecode2 = 0 ;
19487 PyObject * obj0 = 0 ;
19488 PyObject * obj1 = 0 ;
19489 char * kwnames[] = {
19490 (char *) "self",(char *) "orient", NULL
19491 };
19492
19493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19495 if (!SWIG_IsOK(res1)) {
19496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19497 }
19498 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19499 ecode2 = SWIG_AsVal_int(obj1, &val2);
19500 if (!SWIG_IsOK(ecode2)) {
19501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19502 }
19503 arg2 = static_cast< int >(val2);
19504 {
19505 PyThreadState* __tstate = wxPyBeginAllowThreads();
19506 (arg1)->SetOrientation(arg2);
19507 wxPyEndAllowThreads(__tstate);
19508 if (PyErr_Occurred()) SWIG_fail;
19509 }
19510 resultobj = SWIG_Py_Void();
19511 return resultobj;
19512 fail:
19513 return NULL;
19514 }
19515
19516
19517 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19518 PyObject *resultobj = 0;
19519 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19520 int arg2 ;
19521 void *argp1 = 0 ;
19522 int res1 = 0 ;
19523 int val2 ;
19524 int ecode2 = 0 ;
19525 PyObject * obj0 = 0 ;
19526 PyObject * obj1 = 0 ;
19527 char * kwnames[] = {
19528 (char *) "self",(char *) "pos", NULL
19529 };
19530
19531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19533 if (!SWIG_IsOK(res1)) {
19534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19535 }
19536 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19537 ecode2 = SWIG_AsVal_int(obj1, &val2);
19538 if (!SWIG_IsOK(ecode2)) {
19539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19540 }
19541 arg2 = static_cast< int >(val2);
19542 {
19543 PyThreadState* __tstate = wxPyBeginAllowThreads();
19544 (arg1)->SetPosition(arg2);
19545 wxPyEndAllowThreads(__tstate);
19546 if (PyErr_Occurred()) SWIG_fail;
19547 }
19548 resultobj = SWIG_Py_Void();
19549 return resultobj;
19550 fail:
19551 return NULL;
19552 }
19553
19554
19555 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19556 PyObject *obj;
19557 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19558 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19559 return SWIG_Py_Void();
19560 }
19561
19562 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19563 return SWIG_Python_InitShadowInstance(args);
19564 }
19565
19566 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19567 PyObject *resultobj = 0;
19568 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19569 int arg2 = (int) 0 ;
19570 int arg3 = (int) 0 ;
19571 wxScrollWinEvent *result = 0 ;
19572 int val1 ;
19573 int ecode1 = 0 ;
19574 int val2 ;
19575 int ecode2 = 0 ;
19576 int val3 ;
19577 int ecode3 = 0 ;
19578 PyObject * obj0 = 0 ;
19579 PyObject * obj1 = 0 ;
19580 PyObject * obj2 = 0 ;
19581 char * kwnames[] = {
19582 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19583 };
19584
19585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19586 if (obj0) {
19587 ecode1 = SWIG_AsVal_int(obj0, &val1);
19588 if (!SWIG_IsOK(ecode1)) {
19589 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19590 }
19591 arg1 = static_cast< wxEventType >(val1);
19592 }
19593 if (obj1) {
19594 ecode2 = SWIG_AsVal_int(obj1, &val2);
19595 if (!SWIG_IsOK(ecode2)) {
19596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19597 }
19598 arg2 = static_cast< int >(val2);
19599 }
19600 if (obj2) {
19601 ecode3 = SWIG_AsVal_int(obj2, &val3);
19602 if (!SWIG_IsOK(ecode3)) {
19603 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19604 }
19605 arg3 = static_cast< int >(val3);
19606 }
19607 {
19608 PyThreadState* __tstate = wxPyBeginAllowThreads();
19609 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19610 wxPyEndAllowThreads(__tstate);
19611 if (PyErr_Occurred()) SWIG_fail;
19612 }
19613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19614 return resultobj;
19615 fail:
19616 return NULL;
19617 }
19618
19619
19620 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19621 PyObject *resultobj = 0;
19622 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19623 int result;
19624 void *argp1 = 0 ;
19625 int res1 = 0 ;
19626 PyObject *swig_obj[1] ;
19627
19628 if (!args) SWIG_fail;
19629 swig_obj[0] = args;
19630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19631 if (!SWIG_IsOK(res1)) {
19632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19633 }
19634 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19635 {
19636 PyThreadState* __tstate = wxPyBeginAllowThreads();
19637 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19638 wxPyEndAllowThreads(__tstate);
19639 if (PyErr_Occurred()) SWIG_fail;
19640 }
19641 resultobj = SWIG_From_int(static_cast< int >(result));
19642 return resultobj;
19643 fail:
19644 return NULL;
19645 }
19646
19647
19648 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19649 PyObject *resultobj = 0;
19650 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19651 int result;
19652 void *argp1 = 0 ;
19653 int res1 = 0 ;
19654 PyObject *swig_obj[1] ;
19655
19656 if (!args) SWIG_fail;
19657 swig_obj[0] = args;
19658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19659 if (!SWIG_IsOK(res1)) {
19660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19661 }
19662 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19663 {
19664 PyThreadState* __tstate = wxPyBeginAllowThreads();
19665 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19666 wxPyEndAllowThreads(__tstate);
19667 if (PyErr_Occurred()) SWIG_fail;
19668 }
19669 resultobj = SWIG_From_int(static_cast< int >(result));
19670 return resultobj;
19671 fail:
19672 return NULL;
19673 }
19674
19675
19676 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19677 PyObject *resultobj = 0;
19678 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19679 int arg2 ;
19680 void *argp1 = 0 ;
19681 int res1 = 0 ;
19682 int val2 ;
19683 int ecode2 = 0 ;
19684 PyObject * obj0 = 0 ;
19685 PyObject * obj1 = 0 ;
19686 char * kwnames[] = {
19687 (char *) "self",(char *) "orient", NULL
19688 };
19689
19690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19692 if (!SWIG_IsOK(res1)) {
19693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19694 }
19695 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19696 ecode2 = SWIG_AsVal_int(obj1, &val2);
19697 if (!SWIG_IsOK(ecode2)) {
19698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19699 }
19700 arg2 = static_cast< int >(val2);
19701 {
19702 PyThreadState* __tstate = wxPyBeginAllowThreads();
19703 (arg1)->SetOrientation(arg2);
19704 wxPyEndAllowThreads(__tstate);
19705 if (PyErr_Occurred()) SWIG_fail;
19706 }
19707 resultobj = SWIG_Py_Void();
19708 return resultobj;
19709 fail:
19710 return NULL;
19711 }
19712
19713
19714 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19715 PyObject *resultobj = 0;
19716 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19717 int arg2 ;
19718 void *argp1 = 0 ;
19719 int res1 = 0 ;
19720 int val2 ;
19721 int ecode2 = 0 ;
19722 PyObject * obj0 = 0 ;
19723 PyObject * obj1 = 0 ;
19724 char * kwnames[] = {
19725 (char *) "self",(char *) "pos", NULL
19726 };
19727
19728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19730 if (!SWIG_IsOK(res1)) {
19731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19732 }
19733 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19734 ecode2 = SWIG_AsVal_int(obj1, &val2);
19735 if (!SWIG_IsOK(ecode2)) {
19736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19737 }
19738 arg2 = static_cast< int >(val2);
19739 {
19740 PyThreadState* __tstate = wxPyBeginAllowThreads();
19741 (arg1)->SetPosition(arg2);
19742 wxPyEndAllowThreads(__tstate);
19743 if (PyErr_Occurred()) SWIG_fail;
19744 }
19745 resultobj = SWIG_Py_Void();
19746 return resultobj;
19747 fail:
19748 return NULL;
19749 }
19750
19751
19752 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19753 PyObject *obj;
19754 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19755 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19756 return SWIG_Py_Void();
19757 }
19758
19759 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19760 return SWIG_Python_InitShadowInstance(args);
19761 }
19762
19763 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19764 PyObject *resultobj = 0;
19765 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19766 wxMouseEvent *result = 0 ;
19767 int val1 ;
19768 int ecode1 = 0 ;
19769 PyObject * obj0 = 0 ;
19770 char * kwnames[] = {
19771 (char *) "mouseType", NULL
19772 };
19773
19774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19775 if (obj0) {
19776 ecode1 = SWIG_AsVal_int(obj0, &val1);
19777 if (!SWIG_IsOK(ecode1)) {
19778 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19779 }
19780 arg1 = static_cast< wxEventType >(val1);
19781 }
19782 {
19783 PyThreadState* __tstate = wxPyBeginAllowThreads();
19784 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19785 wxPyEndAllowThreads(__tstate);
19786 if (PyErr_Occurred()) SWIG_fail;
19787 }
19788 {
19789 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19790 }
19791 return resultobj;
19792 fail:
19793 return NULL;
19794 }
19795
19796
19797 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19798 PyObject *resultobj = 0;
19799 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19800 bool result;
19801 void *argp1 = 0 ;
19802 int res1 = 0 ;
19803 PyObject *swig_obj[1] ;
19804
19805 if (!args) SWIG_fail;
19806 swig_obj[0] = args;
19807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19808 if (!SWIG_IsOK(res1)) {
19809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19810 }
19811 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19812 {
19813 PyThreadState* __tstate = wxPyBeginAllowThreads();
19814 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19815 wxPyEndAllowThreads(__tstate);
19816 if (PyErr_Occurred()) SWIG_fail;
19817 }
19818 {
19819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19820 }
19821 return resultobj;
19822 fail:
19823 return NULL;
19824 }
19825
19826
19827 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19828 PyObject *resultobj = 0;
19829 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19830 int arg2 = (int) wxMOUSE_BTN_ANY ;
19831 bool result;
19832 void *argp1 = 0 ;
19833 int res1 = 0 ;
19834 int val2 ;
19835 int ecode2 = 0 ;
19836 PyObject * obj0 = 0 ;
19837 PyObject * obj1 = 0 ;
19838 char * kwnames[] = {
19839 (char *) "self",(char *) "but", NULL
19840 };
19841
19842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19844 if (!SWIG_IsOK(res1)) {
19845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19846 }
19847 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19848 if (obj1) {
19849 ecode2 = SWIG_AsVal_int(obj1, &val2);
19850 if (!SWIG_IsOK(ecode2)) {
19851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19852 }
19853 arg2 = static_cast< int >(val2);
19854 }
19855 {
19856 PyThreadState* __tstate = wxPyBeginAllowThreads();
19857 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19858 wxPyEndAllowThreads(__tstate);
19859 if (PyErr_Occurred()) SWIG_fail;
19860 }
19861 {
19862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19863 }
19864 return resultobj;
19865 fail:
19866 return NULL;
19867 }
19868
19869
19870 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19871 PyObject *resultobj = 0;
19872 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19873 int arg2 = (int) wxMOUSE_BTN_ANY ;
19874 bool result;
19875 void *argp1 = 0 ;
19876 int res1 = 0 ;
19877 int val2 ;
19878 int ecode2 = 0 ;
19879 PyObject * obj0 = 0 ;
19880 PyObject * obj1 = 0 ;
19881 char * kwnames[] = {
19882 (char *) "self",(char *) "but", NULL
19883 };
19884
19885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19887 if (!SWIG_IsOK(res1)) {
19888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19889 }
19890 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19891 if (obj1) {
19892 ecode2 = SWIG_AsVal_int(obj1, &val2);
19893 if (!SWIG_IsOK(ecode2)) {
19894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19895 }
19896 arg2 = static_cast< int >(val2);
19897 }
19898 {
19899 PyThreadState* __tstate = wxPyBeginAllowThreads();
19900 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19901 wxPyEndAllowThreads(__tstate);
19902 if (PyErr_Occurred()) SWIG_fail;
19903 }
19904 {
19905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19906 }
19907 return resultobj;
19908 fail:
19909 return NULL;
19910 }
19911
19912
19913 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19914 PyObject *resultobj = 0;
19915 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19916 int arg2 = (int) wxMOUSE_BTN_ANY ;
19917 bool result;
19918 void *argp1 = 0 ;
19919 int res1 = 0 ;
19920 int val2 ;
19921 int ecode2 = 0 ;
19922 PyObject * obj0 = 0 ;
19923 PyObject * obj1 = 0 ;
19924 char * kwnames[] = {
19925 (char *) "self",(char *) "but", NULL
19926 };
19927
19928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19930 if (!SWIG_IsOK(res1)) {
19931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19932 }
19933 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19934 if (obj1) {
19935 ecode2 = SWIG_AsVal_int(obj1, &val2);
19936 if (!SWIG_IsOK(ecode2)) {
19937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19938 }
19939 arg2 = static_cast< int >(val2);
19940 }
19941 {
19942 PyThreadState* __tstate = wxPyBeginAllowThreads();
19943 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19944 wxPyEndAllowThreads(__tstate);
19945 if (PyErr_Occurred()) SWIG_fail;
19946 }
19947 {
19948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19949 }
19950 return resultobj;
19951 fail:
19952 return NULL;
19953 }
19954
19955
19956 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19957 PyObject *resultobj = 0;
19958 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19959 int arg2 ;
19960 bool result;
19961 void *argp1 = 0 ;
19962 int res1 = 0 ;
19963 int val2 ;
19964 int ecode2 = 0 ;
19965 PyObject * obj0 = 0 ;
19966 PyObject * obj1 = 0 ;
19967 char * kwnames[] = {
19968 (char *) "self",(char *) "button", NULL
19969 };
19970
19971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19973 if (!SWIG_IsOK(res1)) {
19974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19975 }
19976 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19977 ecode2 = SWIG_AsVal_int(obj1, &val2);
19978 if (!SWIG_IsOK(ecode2)) {
19979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19980 }
19981 arg2 = static_cast< int >(val2);
19982 {
19983 PyThreadState* __tstate = wxPyBeginAllowThreads();
19984 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19985 wxPyEndAllowThreads(__tstate);
19986 if (PyErr_Occurred()) SWIG_fail;
19987 }
19988 {
19989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19990 }
19991 return resultobj;
19992 fail:
19993 return NULL;
19994 }
19995
19996
19997 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19998 PyObject *resultobj = 0;
19999 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20000 int arg2 ;
20001 bool result;
20002 void *argp1 = 0 ;
20003 int res1 = 0 ;
20004 int val2 ;
20005 int ecode2 = 0 ;
20006 PyObject * obj0 = 0 ;
20007 PyObject * obj1 = 0 ;
20008 char * kwnames[] = {
20009 (char *) "self",(char *) "but", NULL
20010 };
20011
20012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20014 if (!SWIG_IsOK(res1)) {
20015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20016 }
20017 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20018 ecode2 = SWIG_AsVal_int(obj1, &val2);
20019 if (!SWIG_IsOK(ecode2)) {
20020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20021 }
20022 arg2 = static_cast< int >(val2);
20023 {
20024 PyThreadState* __tstate = wxPyBeginAllowThreads();
20025 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20026 wxPyEndAllowThreads(__tstate);
20027 if (PyErr_Occurred()) SWIG_fail;
20028 }
20029 {
20030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20031 }
20032 return resultobj;
20033 fail:
20034 return NULL;
20035 }
20036
20037
20038 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20039 PyObject *resultobj = 0;
20040 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20041 int result;
20042 void *argp1 = 0 ;
20043 int res1 = 0 ;
20044 PyObject *swig_obj[1] ;
20045
20046 if (!args) SWIG_fail;
20047 swig_obj[0] = args;
20048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20049 if (!SWIG_IsOK(res1)) {
20050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20051 }
20052 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20053 {
20054 PyThreadState* __tstate = wxPyBeginAllowThreads();
20055 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20056 wxPyEndAllowThreads(__tstate);
20057 if (PyErr_Occurred()) SWIG_fail;
20058 }
20059 resultobj = SWIG_From_int(static_cast< int >(result));
20060 return resultobj;
20061 fail:
20062 return NULL;
20063 }
20064
20065
20066 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20067 PyObject *resultobj = 0;
20068 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20069 bool result;
20070 void *argp1 = 0 ;
20071 int res1 = 0 ;
20072 PyObject *swig_obj[1] ;
20073
20074 if (!args) SWIG_fail;
20075 swig_obj[0] = args;
20076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20077 if (!SWIG_IsOK(res1)) {
20078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20079 }
20080 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20081 {
20082 PyThreadState* __tstate = wxPyBeginAllowThreads();
20083 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20084 wxPyEndAllowThreads(__tstate);
20085 if (PyErr_Occurred()) SWIG_fail;
20086 }
20087 {
20088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20089 }
20090 return resultobj;
20091 fail:
20092 return NULL;
20093 }
20094
20095
20096 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20097 PyObject *resultobj = 0;
20098 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20099 bool result;
20100 void *argp1 = 0 ;
20101 int res1 = 0 ;
20102 PyObject *swig_obj[1] ;
20103
20104 if (!args) SWIG_fail;
20105 swig_obj[0] = args;
20106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20107 if (!SWIG_IsOK(res1)) {
20108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20109 }
20110 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20111 {
20112 PyThreadState* __tstate = wxPyBeginAllowThreads();
20113 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20114 wxPyEndAllowThreads(__tstate);
20115 if (PyErr_Occurred()) SWIG_fail;
20116 }
20117 {
20118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20119 }
20120 return resultobj;
20121 fail:
20122 return NULL;
20123 }
20124
20125
20126 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20127 PyObject *resultobj = 0;
20128 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20129 bool result;
20130 void *argp1 = 0 ;
20131 int res1 = 0 ;
20132 PyObject *swig_obj[1] ;
20133
20134 if (!args) SWIG_fail;
20135 swig_obj[0] = args;
20136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20137 if (!SWIG_IsOK(res1)) {
20138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20139 }
20140 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20141 {
20142 PyThreadState* __tstate = wxPyBeginAllowThreads();
20143 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20144 wxPyEndAllowThreads(__tstate);
20145 if (PyErr_Occurred()) SWIG_fail;
20146 }
20147 {
20148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20149 }
20150 return resultobj;
20151 fail:
20152 return NULL;
20153 }
20154
20155
20156 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20157 PyObject *resultobj = 0;
20158 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20159 bool result;
20160 void *argp1 = 0 ;
20161 int res1 = 0 ;
20162 PyObject *swig_obj[1] ;
20163
20164 if (!args) SWIG_fail;
20165 swig_obj[0] = args;
20166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20167 if (!SWIG_IsOK(res1)) {
20168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20169 }
20170 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20171 {
20172 PyThreadState* __tstate = wxPyBeginAllowThreads();
20173 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20174 wxPyEndAllowThreads(__tstate);
20175 if (PyErr_Occurred()) SWIG_fail;
20176 }
20177 {
20178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20179 }
20180 return resultobj;
20181 fail:
20182 return NULL;
20183 }
20184
20185
20186 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20187 PyObject *resultobj = 0;
20188 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20189 bool result;
20190 void *argp1 = 0 ;
20191 int res1 = 0 ;
20192 PyObject *swig_obj[1] ;
20193
20194 if (!args) SWIG_fail;
20195 swig_obj[0] = args;
20196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20197 if (!SWIG_IsOK(res1)) {
20198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20199 }
20200 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20201 {
20202 PyThreadState* __tstate = wxPyBeginAllowThreads();
20203 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20204 wxPyEndAllowThreads(__tstate);
20205 if (PyErr_Occurred()) SWIG_fail;
20206 }
20207 {
20208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20209 }
20210 return resultobj;
20211 fail:
20212 return NULL;
20213 }
20214
20215
20216 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20217 PyObject *resultobj = 0;
20218 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20219 bool result;
20220 void *argp1 = 0 ;
20221 int res1 = 0 ;
20222 PyObject *swig_obj[1] ;
20223
20224 if (!args) SWIG_fail;
20225 swig_obj[0] = args;
20226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20227 if (!SWIG_IsOK(res1)) {
20228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20229 }
20230 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20231 {
20232 PyThreadState* __tstate = wxPyBeginAllowThreads();
20233 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20234 wxPyEndAllowThreads(__tstate);
20235 if (PyErr_Occurred()) SWIG_fail;
20236 }
20237 {
20238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20239 }
20240 return resultobj;
20241 fail:
20242 return NULL;
20243 }
20244
20245
20246 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20247 PyObject *resultobj = 0;
20248 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20249 bool result;
20250 void *argp1 = 0 ;
20251 int res1 = 0 ;
20252 PyObject *swig_obj[1] ;
20253
20254 if (!args) SWIG_fail;
20255 swig_obj[0] = args;
20256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20257 if (!SWIG_IsOK(res1)) {
20258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20259 }
20260 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20261 {
20262 PyThreadState* __tstate = wxPyBeginAllowThreads();
20263 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20264 wxPyEndAllowThreads(__tstate);
20265 if (PyErr_Occurred()) SWIG_fail;
20266 }
20267 {
20268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20269 }
20270 return resultobj;
20271 fail:
20272 return NULL;
20273 }
20274
20275
20276 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20277 PyObject *resultobj = 0;
20278 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20279 bool result;
20280 void *argp1 = 0 ;
20281 int res1 = 0 ;
20282 PyObject *swig_obj[1] ;
20283
20284 if (!args) SWIG_fail;
20285 swig_obj[0] = args;
20286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20287 if (!SWIG_IsOK(res1)) {
20288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20289 }
20290 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20291 {
20292 PyThreadState* __tstate = wxPyBeginAllowThreads();
20293 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20294 wxPyEndAllowThreads(__tstate);
20295 if (PyErr_Occurred()) SWIG_fail;
20296 }
20297 {
20298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20299 }
20300 return resultobj;
20301 fail:
20302 return NULL;
20303 }
20304
20305
20306 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20307 PyObject *resultobj = 0;
20308 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20309 bool result;
20310 void *argp1 = 0 ;
20311 int res1 = 0 ;
20312 PyObject *swig_obj[1] ;
20313
20314 if (!args) SWIG_fail;
20315 swig_obj[0] = args;
20316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20317 if (!SWIG_IsOK(res1)) {
20318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20319 }
20320 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20321 {
20322 PyThreadState* __tstate = wxPyBeginAllowThreads();
20323 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20324 wxPyEndAllowThreads(__tstate);
20325 if (PyErr_Occurred()) SWIG_fail;
20326 }
20327 {
20328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20329 }
20330 return resultobj;
20331 fail:
20332 return NULL;
20333 }
20334
20335
20336 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20337 PyObject *resultobj = 0;
20338 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20339 bool result;
20340 void *argp1 = 0 ;
20341 int res1 = 0 ;
20342 PyObject *swig_obj[1] ;
20343
20344 if (!args) SWIG_fail;
20345 swig_obj[0] = args;
20346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20347 if (!SWIG_IsOK(res1)) {
20348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20349 }
20350 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20351 {
20352 PyThreadState* __tstate = wxPyBeginAllowThreads();
20353 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20354 wxPyEndAllowThreads(__tstate);
20355 if (PyErr_Occurred()) SWIG_fail;
20356 }
20357 {
20358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20359 }
20360 return resultobj;
20361 fail:
20362 return NULL;
20363 }
20364
20365
20366 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20367 PyObject *resultobj = 0;
20368 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20369 bool result;
20370 void *argp1 = 0 ;
20371 int res1 = 0 ;
20372 PyObject *swig_obj[1] ;
20373
20374 if (!args) SWIG_fail;
20375 swig_obj[0] = args;
20376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20377 if (!SWIG_IsOK(res1)) {
20378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20379 }
20380 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20381 {
20382 PyThreadState* __tstate = wxPyBeginAllowThreads();
20383 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20384 wxPyEndAllowThreads(__tstate);
20385 if (PyErr_Occurred()) SWIG_fail;
20386 }
20387 {
20388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20389 }
20390 return resultobj;
20391 fail:
20392 return NULL;
20393 }
20394
20395
20396 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20397 PyObject *resultobj = 0;
20398 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20399 bool result;
20400 void *argp1 = 0 ;
20401 int res1 = 0 ;
20402 PyObject *swig_obj[1] ;
20403
20404 if (!args) SWIG_fail;
20405 swig_obj[0] = args;
20406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20407 if (!SWIG_IsOK(res1)) {
20408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20409 }
20410 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20411 {
20412 PyThreadState* __tstate = wxPyBeginAllowThreads();
20413 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20414 wxPyEndAllowThreads(__tstate);
20415 if (PyErr_Occurred()) SWIG_fail;
20416 }
20417 {
20418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20419 }
20420 return resultobj;
20421 fail:
20422 return NULL;
20423 }
20424
20425
20426 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20427 PyObject *resultobj = 0;
20428 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20429 bool result;
20430 void *argp1 = 0 ;
20431 int res1 = 0 ;
20432 PyObject *swig_obj[1] ;
20433
20434 if (!args) SWIG_fail;
20435 swig_obj[0] = args;
20436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20437 if (!SWIG_IsOK(res1)) {
20438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20439 }
20440 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20441 {
20442 PyThreadState* __tstate = wxPyBeginAllowThreads();
20443 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20444 wxPyEndAllowThreads(__tstate);
20445 if (PyErr_Occurred()) SWIG_fail;
20446 }
20447 {
20448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20449 }
20450 return resultobj;
20451 fail:
20452 return NULL;
20453 }
20454
20455
20456 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20457 PyObject *resultobj = 0;
20458 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20459 bool result;
20460 void *argp1 = 0 ;
20461 int res1 = 0 ;
20462 PyObject *swig_obj[1] ;
20463
20464 if (!args) SWIG_fail;
20465 swig_obj[0] = args;
20466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20467 if (!SWIG_IsOK(res1)) {
20468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20469 }
20470 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20471 {
20472 PyThreadState* __tstate = wxPyBeginAllowThreads();
20473 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20474 wxPyEndAllowThreads(__tstate);
20475 if (PyErr_Occurred()) SWIG_fail;
20476 }
20477 {
20478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20479 }
20480 return resultobj;
20481 fail:
20482 return NULL;
20483 }
20484
20485
20486 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20487 PyObject *resultobj = 0;
20488 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20489 bool result;
20490 void *argp1 = 0 ;
20491 int res1 = 0 ;
20492 PyObject *swig_obj[1] ;
20493
20494 if (!args) SWIG_fail;
20495 swig_obj[0] = args;
20496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20497 if (!SWIG_IsOK(res1)) {
20498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20499 }
20500 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20501 {
20502 PyThreadState* __tstate = wxPyBeginAllowThreads();
20503 result = (bool)(arg1)->LeftIsDown();
20504 wxPyEndAllowThreads(__tstate);
20505 if (PyErr_Occurred()) SWIG_fail;
20506 }
20507 {
20508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20509 }
20510 return resultobj;
20511 fail:
20512 return NULL;
20513 }
20514
20515
20516 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20517 PyObject *resultobj = 0;
20518 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20519 bool result;
20520 void *argp1 = 0 ;
20521 int res1 = 0 ;
20522 PyObject *swig_obj[1] ;
20523
20524 if (!args) SWIG_fail;
20525 swig_obj[0] = args;
20526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20527 if (!SWIG_IsOK(res1)) {
20528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20529 }
20530 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20531 {
20532 PyThreadState* __tstate = wxPyBeginAllowThreads();
20533 result = (bool)(arg1)->MiddleIsDown();
20534 wxPyEndAllowThreads(__tstate);
20535 if (PyErr_Occurred()) SWIG_fail;
20536 }
20537 {
20538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20539 }
20540 return resultobj;
20541 fail:
20542 return NULL;
20543 }
20544
20545
20546 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20547 PyObject *resultobj = 0;
20548 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20549 bool result;
20550 void *argp1 = 0 ;
20551 int res1 = 0 ;
20552 PyObject *swig_obj[1] ;
20553
20554 if (!args) SWIG_fail;
20555 swig_obj[0] = args;
20556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20557 if (!SWIG_IsOK(res1)) {
20558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20559 }
20560 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20561 {
20562 PyThreadState* __tstate = wxPyBeginAllowThreads();
20563 result = (bool)(arg1)->RightIsDown();
20564 wxPyEndAllowThreads(__tstate);
20565 if (PyErr_Occurred()) SWIG_fail;
20566 }
20567 {
20568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20569 }
20570 return resultobj;
20571 fail:
20572 return NULL;
20573 }
20574
20575
20576 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20577 PyObject *resultobj = 0;
20578 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20579 bool result;
20580 void *argp1 = 0 ;
20581 int res1 = 0 ;
20582 PyObject *swig_obj[1] ;
20583
20584 if (!args) SWIG_fail;
20585 swig_obj[0] = args;
20586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20587 if (!SWIG_IsOK(res1)) {
20588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20589 }
20590 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20591 {
20592 PyThreadState* __tstate = wxPyBeginAllowThreads();
20593 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20594 wxPyEndAllowThreads(__tstate);
20595 if (PyErr_Occurred()) SWIG_fail;
20596 }
20597 {
20598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20599 }
20600 return resultobj;
20601 fail:
20602 return NULL;
20603 }
20604
20605
20606 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20607 PyObject *resultobj = 0;
20608 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20609 bool result;
20610 void *argp1 = 0 ;
20611 int res1 = 0 ;
20612 PyObject *swig_obj[1] ;
20613
20614 if (!args) SWIG_fail;
20615 swig_obj[0] = args;
20616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20617 if (!SWIG_IsOK(res1)) {
20618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20619 }
20620 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20621 {
20622 PyThreadState* __tstate = wxPyBeginAllowThreads();
20623 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20624 wxPyEndAllowThreads(__tstate);
20625 if (PyErr_Occurred()) SWIG_fail;
20626 }
20627 {
20628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20629 }
20630 return resultobj;
20631 fail:
20632 return NULL;
20633 }
20634
20635
20636 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20637 PyObject *resultobj = 0;
20638 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20639 bool result;
20640 void *argp1 = 0 ;
20641 int res1 = 0 ;
20642 PyObject *swig_obj[1] ;
20643
20644 if (!args) SWIG_fail;
20645 swig_obj[0] = args;
20646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20647 if (!SWIG_IsOK(res1)) {
20648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20649 }
20650 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20651 {
20652 PyThreadState* __tstate = wxPyBeginAllowThreads();
20653 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20654 wxPyEndAllowThreads(__tstate);
20655 if (PyErr_Occurred()) SWIG_fail;
20656 }
20657 {
20658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20659 }
20660 return resultobj;
20661 fail:
20662 return NULL;
20663 }
20664
20665
20666 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20667 PyObject *resultobj = 0;
20668 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20669 bool result;
20670 void *argp1 = 0 ;
20671 int res1 = 0 ;
20672 PyObject *swig_obj[1] ;
20673
20674 if (!args) SWIG_fail;
20675 swig_obj[0] = args;
20676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20677 if (!SWIG_IsOK(res1)) {
20678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20679 }
20680 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20681 {
20682 PyThreadState* __tstate = wxPyBeginAllowThreads();
20683 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20684 wxPyEndAllowThreads(__tstate);
20685 if (PyErr_Occurred()) SWIG_fail;
20686 }
20687 {
20688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20689 }
20690 return resultobj;
20691 fail:
20692 return NULL;
20693 }
20694
20695
20696 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20697 PyObject *resultobj = 0;
20698 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20699 wxPoint result;
20700 void *argp1 = 0 ;
20701 int res1 = 0 ;
20702 PyObject *swig_obj[1] ;
20703
20704 if (!args) SWIG_fail;
20705 swig_obj[0] = args;
20706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20707 if (!SWIG_IsOK(res1)) {
20708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20709 }
20710 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20711 {
20712 PyThreadState* __tstate = wxPyBeginAllowThreads();
20713 result = (arg1)->GetPosition();
20714 wxPyEndAllowThreads(__tstate);
20715 if (PyErr_Occurred()) SWIG_fail;
20716 }
20717 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20718 return resultobj;
20719 fail:
20720 return NULL;
20721 }
20722
20723
20724 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20725 PyObject *resultobj = 0;
20726 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20727 long *arg2 = (long *) 0 ;
20728 long *arg3 = (long *) 0 ;
20729 void *argp1 = 0 ;
20730 int res1 = 0 ;
20731 long temp2 ;
20732 int res2 = SWIG_TMPOBJ ;
20733 long temp3 ;
20734 int res3 = SWIG_TMPOBJ ;
20735 PyObject *swig_obj[1] ;
20736
20737 arg2 = &temp2;
20738 arg3 = &temp3;
20739 if (!args) SWIG_fail;
20740 swig_obj[0] = args;
20741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20742 if (!SWIG_IsOK(res1)) {
20743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20744 }
20745 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20746 {
20747 PyThreadState* __tstate = wxPyBeginAllowThreads();
20748 (arg1)->GetPosition(arg2,arg3);
20749 wxPyEndAllowThreads(__tstate);
20750 if (PyErr_Occurred()) SWIG_fail;
20751 }
20752 resultobj = SWIG_Py_Void();
20753 if (SWIG_IsTmpObj(res2)) {
20754 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20755 } else {
20756 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20757 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20758 }
20759 if (SWIG_IsTmpObj(res3)) {
20760 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20761 } else {
20762 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20763 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20764 }
20765 return resultobj;
20766 fail:
20767 return NULL;
20768 }
20769
20770
20771 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20772 PyObject *resultobj = 0;
20773 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20774 wxDC *arg2 = 0 ;
20775 wxPoint result;
20776 void *argp1 = 0 ;
20777 int res1 = 0 ;
20778 void *argp2 = 0 ;
20779 int res2 = 0 ;
20780 PyObject * obj0 = 0 ;
20781 PyObject * obj1 = 0 ;
20782 char * kwnames[] = {
20783 (char *) "self",(char *) "dc", NULL
20784 };
20785
20786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20788 if (!SWIG_IsOK(res1)) {
20789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20790 }
20791 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20792 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20793 if (!SWIG_IsOK(res2)) {
20794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20795 }
20796 if (!argp2) {
20797 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20798 }
20799 arg2 = reinterpret_cast< wxDC * >(argp2);
20800 {
20801 PyThreadState* __tstate = wxPyBeginAllowThreads();
20802 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20803 wxPyEndAllowThreads(__tstate);
20804 if (PyErr_Occurred()) SWIG_fail;
20805 }
20806 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20807 return resultobj;
20808 fail:
20809 return NULL;
20810 }
20811
20812
20813 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20814 PyObject *resultobj = 0;
20815 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20816 int result;
20817 void *argp1 = 0 ;
20818 int res1 = 0 ;
20819 PyObject *swig_obj[1] ;
20820
20821 if (!args) SWIG_fail;
20822 swig_obj[0] = args;
20823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20824 if (!SWIG_IsOK(res1)) {
20825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20826 }
20827 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20828 {
20829 PyThreadState* __tstate = wxPyBeginAllowThreads();
20830 result = (int)((wxMouseEvent const *)arg1)->GetX();
20831 wxPyEndAllowThreads(__tstate);
20832 if (PyErr_Occurred()) SWIG_fail;
20833 }
20834 resultobj = SWIG_From_int(static_cast< int >(result));
20835 return resultobj;
20836 fail:
20837 return NULL;
20838 }
20839
20840
20841 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20842 PyObject *resultobj = 0;
20843 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20844 int result;
20845 void *argp1 = 0 ;
20846 int res1 = 0 ;
20847 PyObject *swig_obj[1] ;
20848
20849 if (!args) SWIG_fail;
20850 swig_obj[0] = args;
20851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20852 if (!SWIG_IsOK(res1)) {
20853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20854 }
20855 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20856 {
20857 PyThreadState* __tstate = wxPyBeginAllowThreads();
20858 result = (int)((wxMouseEvent const *)arg1)->GetY();
20859 wxPyEndAllowThreads(__tstate);
20860 if (PyErr_Occurred()) SWIG_fail;
20861 }
20862 resultobj = SWIG_From_int(static_cast< int >(result));
20863 return resultobj;
20864 fail:
20865 return NULL;
20866 }
20867
20868
20869 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20870 PyObject *resultobj = 0;
20871 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20872 int result;
20873 void *argp1 = 0 ;
20874 int res1 = 0 ;
20875 PyObject *swig_obj[1] ;
20876
20877 if (!args) SWIG_fail;
20878 swig_obj[0] = args;
20879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20880 if (!SWIG_IsOK(res1)) {
20881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20882 }
20883 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20884 {
20885 PyThreadState* __tstate = wxPyBeginAllowThreads();
20886 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20887 wxPyEndAllowThreads(__tstate);
20888 if (PyErr_Occurred()) SWIG_fail;
20889 }
20890 resultobj = SWIG_From_int(static_cast< int >(result));
20891 return resultobj;
20892 fail:
20893 return NULL;
20894 }
20895
20896
20897 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20898 PyObject *resultobj = 0;
20899 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20900 int result;
20901 void *argp1 = 0 ;
20902 int res1 = 0 ;
20903 PyObject *swig_obj[1] ;
20904
20905 if (!args) SWIG_fail;
20906 swig_obj[0] = args;
20907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20908 if (!SWIG_IsOK(res1)) {
20909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20910 }
20911 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20912 {
20913 PyThreadState* __tstate = wxPyBeginAllowThreads();
20914 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20915 wxPyEndAllowThreads(__tstate);
20916 if (PyErr_Occurred()) SWIG_fail;
20917 }
20918 resultobj = SWIG_From_int(static_cast< int >(result));
20919 return resultobj;
20920 fail:
20921 return NULL;
20922 }
20923
20924
20925 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20926 PyObject *resultobj = 0;
20927 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20928 int result;
20929 void *argp1 = 0 ;
20930 int res1 = 0 ;
20931 PyObject *swig_obj[1] ;
20932
20933 if (!args) SWIG_fail;
20934 swig_obj[0] = args;
20935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20936 if (!SWIG_IsOK(res1)) {
20937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20938 }
20939 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20940 {
20941 PyThreadState* __tstate = wxPyBeginAllowThreads();
20942 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20943 wxPyEndAllowThreads(__tstate);
20944 if (PyErr_Occurred()) SWIG_fail;
20945 }
20946 resultobj = SWIG_From_int(static_cast< int >(result));
20947 return resultobj;
20948 fail:
20949 return NULL;
20950 }
20951
20952
20953 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20954 PyObject *resultobj = 0;
20955 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20956 bool result;
20957 void *argp1 = 0 ;
20958 int res1 = 0 ;
20959 PyObject *swig_obj[1] ;
20960
20961 if (!args) SWIG_fail;
20962 swig_obj[0] = args;
20963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20964 if (!SWIG_IsOK(res1)) {
20965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20966 }
20967 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20968 {
20969 PyThreadState* __tstate = wxPyBeginAllowThreads();
20970 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20971 wxPyEndAllowThreads(__tstate);
20972 if (PyErr_Occurred()) SWIG_fail;
20973 }
20974 {
20975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20976 }
20977 return resultobj;
20978 fail:
20979 return NULL;
20980 }
20981
20982
20983 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20984 PyObject *resultobj = 0;
20985 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20986 int arg2 ;
20987 void *argp1 = 0 ;
20988 int res1 = 0 ;
20989 int val2 ;
20990 int ecode2 = 0 ;
20991 PyObject *swig_obj[2] ;
20992
20993 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20995 if (!SWIG_IsOK(res1)) {
20996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20997 }
20998 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20999 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21000 if (!SWIG_IsOK(ecode2)) {
21001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21002 }
21003 arg2 = static_cast< int >(val2);
21004 if (arg1) (arg1)->m_x = arg2;
21005
21006 resultobj = SWIG_Py_Void();
21007 return resultobj;
21008 fail:
21009 return NULL;
21010 }
21011
21012
21013 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21014 PyObject *resultobj = 0;
21015 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21016 int result;
21017 void *argp1 = 0 ;
21018 int res1 = 0 ;
21019 PyObject *swig_obj[1] ;
21020
21021 if (!args) SWIG_fail;
21022 swig_obj[0] = args;
21023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21024 if (!SWIG_IsOK(res1)) {
21025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21026 }
21027 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21028 result = (int) ((arg1)->m_x);
21029 resultobj = SWIG_From_int(static_cast< int >(result));
21030 return resultobj;
21031 fail:
21032 return NULL;
21033 }
21034
21035
21036 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21037 PyObject *resultobj = 0;
21038 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21039 int arg2 ;
21040 void *argp1 = 0 ;
21041 int res1 = 0 ;
21042 int val2 ;
21043 int ecode2 = 0 ;
21044 PyObject *swig_obj[2] ;
21045
21046 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21048 if (!SWIG_IsOK(res1)) {
21049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21050 }
21051 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21052 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21053 if (!SWIG_IsOK(ecode2)) {
21054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21055 }
21056 arg2 = static_cast< int >(val2);
21057 if (arg1) (arg1)->m_y = arg2;
21058
21059 resultobj = SWIG_Py_Void();
21060 return resultobj;
21061 fail:
21062 return NULL;
21063 }
21064
21065
21066 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21067 PyObject *resultobj = 0;
21068 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21069 int result;
21070 void *argp1 = 0 ;
21071 int res1 = 0 ;
21072 PyObject *swig_obj[1] ;
21073
21074 if (!args) SWIG_fail;
21075 swig_obj[0] = args;
21076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21077 if (!SWIG_IsOK(res1)) {
21078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21079 }
21080 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21081 result = (int) ((arg1)->m_y);
21082 resultobj = SWIG_From_int(static_cast< int >(result));
21083 return resultobj;
21084 fail:
21085 return NULL;
21086 }
21087
21088
21089 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21090 PyObject *resultobj = 0;
21091 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21092 bool arg2 ;
21093 void *argp1 = 0 ;
21094 int res1 = 0 ;
21095 bool val2 ;
21096 int ecode2 = 0 ;
21097 PyObject *swig_obj[2] ;
21098
21099 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21101 if (!SWIG_IsOK(res1)) {
21102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21103 }
21104 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21105 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21106 if (!SWIG_IsOK(ecode2)) {
21107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21108 }
21109 arg2 = static_cast< bool >(val2);
21110 if (arg1) (arg1)->m_leftDown = arg2;
21111
21112 resultobj = SWIG_Py_Void();
21113 return resultobj;
21114 fail:
21115 return NULL;
21116 }
21117
21118
21119 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21120 PyObject *resultobj = 0;
21121 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21122 bool result;
21123 void *argp1 = 0 ;
21124 int res1 = 0 ;
21125 PyObject *swig_obj[1] ;
21126
21127 if (!args) SWIG_fail;
21128 swig_obj[0] = args;
21129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21130 if (!SWIG_IsOK(res1)) {
21131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21132 }
21133 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21134 result = (bool) ((arg1)->m_leftDown);
21135 {
21136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21137 }
21138 return resultobj;
21139 fail:
21140 return NULL;
21141 }
21142
21143
21144 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21145 PyObject *resultobj = 0;
21146 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21147 bool arg2 ;
21148 void *argp1 = 0 ;
21149 int res1 = 0 ;
21150 bool val2 ;
21151 int ecode2 = 0 ;
21152 PyObject *swig_obj[2] ;
21153
21154 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21156 if (!SWIG_IsOK(res1)) {
21157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21158 }
21159 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21160 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21161 if (!SWIG_IsOK(ecode2)) {
21162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21163 }
21164 arg2 = static_cast< bool >(val2);
21165 if (arg1) (arg1)->m_middleDown = arg2;
21166
21167 resultobj = SWIG_Py_Void();
21168 return resultobj;
21169 fail:
21170 return NULL;
21171 }
21172
21173
21174 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21175 PyObject *resultobj = 0;
21176 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21177 bool result;
21178 void *argp1 = 0 ;
21179 int res1 = 0 ;
21180 PyObject *swig_obj[1] ;
21181
21182 if (!args) SWIG_fail;
21183 swig_obj[0] = args;
21184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21185 if (!SWIG_IsOK(res1)) {
21186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21187 }
21188 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21189 result = (bool) ((arg1)->m_middleDown);
21190 {
21191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21192 }
21193 return resultobj;
21194 fail:
21195 return NULL;
21196 }
21197
21198
21199 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21200 PyObject *resultobj = 0;
21201 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21202 bool arg2 ;
21203 void *argp1 = 0 ;
21204 int res1 = 0 ;
21205 bool val2 ;
21206 int ecode2 = 0 ;
21207 PyObject *swig_obj[2] ;
21208
21209 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21211 if (!SWIG_IsOK(res1)) {
21212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21213 }
21214 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21215 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21216 if (!SWIG_IsOK(ecode2)) {
21217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21218 }
21219 arg2 = static_cast< bool >(val2);
21220 if (arg1) (arg1)->m_rightDown = arg2;
21221
21222 resultobj = SWIG_Py_Void();
21223 return resultobj;
21224 fail:
21225 return NULL;
21226 }
21227
21228
21229 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21230 PyObject *resultobj = 0;
21231 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21232 bool result;
21233 void *argp1 = 0 ;
21234 int res1 = 0 ;
21235 PyObject *swig_obj[1] ;
21236
21237 if (!args) SWIG_fail;
21238 swig_obj[0] = args;
21239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21240 if (!SWIG_IsOK(res1)) {
21241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21242 }
21243 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21244 result = (bool) ((arg1)->m_rightDown);
21245 {
21246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21247 }
21248 return resultobj;
21249 fail:
21250 return NULL;
21251 }
21252
21253
21254 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21255 PyObject *resultobj = 0;
21256 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21257 bool arg2 ;
21258 void *argp1 = 0 ;
21259 int res1 = 0 ;
21260 bool val2 ;
21261 int ecode2 = 0 ;
21262 PyObject *swig_obj[2] ;
21263
21264 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21266 if (!SWIG_IsOK(res1)) {
21267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21268 }
21269 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21270 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21271 if (!SWIG_IsOK(ecode2)) {
21272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21273 }
21274 arg2 = static_cast< bool >(val2);
21275 if (arg1) (arg1)->m_controlDown = arg2;
21276
21277 resultobj = SWIG_Py_Void();
21278 return resultobj;
21279 fail:
21280 return NULL;
21281 }
21282
21283
21284 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21285 PyObject *resultobj = 0;
21286 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21287 bool result;
21288 void *argp1 = 0 ;
21289 int res1 = 0 ;
21290 PyObject *swig_obj[1] ;
21291
21292 if (!args) SWIG_fail;
21293 swig_obj[0] = args;
21294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21295 if (!SWIG_IsOK(res1)) {
21296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21297 }
21298 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21299 result = (bool) ((arg1)->m_controlDown);
21300 {
21301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21302 }
21303 return resultobj;
21304 fail:
21305 return NULL;
21306 }
21307
21308
21309 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21310 PyObject *resultobj = 0;
21311 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21312 bool arg2 ;
21313 void *argp1 = 0 ;
21314 int res1 = 0 ;
21315 bool val2 ;
21316 int ecode2 = 0 ;
21317 PyObject *swig_obj[2] ;
21318
21319 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21321 if (!SWIG_IsOK(res1)) {
21322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21323 }
21324 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21325 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21326 if (!SWIG_IsOK(ecode2)) {
21327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21328 }
21329 arg2 = static_cast< bool >(val2);
21330 if (arg1) (arg1)->m_shiftDown = arg2;
21331
21332 resultobj = SWIG_Py_Void();
21333 return resultobj;
21334 fail:
21335 return NULL;
21336 }
21337
21338
21339 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21340 PyObject *resultobj = 0;
21341 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21342 bool result;
21343 void *argp1 = 0 ;
21344 int res1 = 0 ;
21345 PyObject *swig_obj[1] ;
21346
21347 if (!args) SWIG_fail;
21348 swig_obj[0] = args;
21349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21350 if (!SWIG_IsOK(res1)) {
21351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21352 }
21353 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21354 result = (bool) ((arg1)->m_shiftDown);
21355 {
21356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21357 }
21358 return resultobj;
21359 fail:
21360 return NULL;
21361 }
21362
21363
21364 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21365 PyObject *resultobj = 0;
21366 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21367 bool arg2 ;
21368 void *argp1 = 0 ;
21369 int res1 = 0 ;
21370 bool val2 ;
21371 int ecode2 = 0 ;
21372 PyObject *swig_obj[2] ;
21373
21374 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21376 if (!SWIG_IsOK(res1)) {
21377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21378 }
21379 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21380 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21381 if (!SWIG_IsOK(ecode2)) {
21382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21383 }
21384 arg2 = static_cast< bool >(val2);
21385 if (arg1) (arg1)->m_altDown = arg2;
21386
21387 resultobj = SWIG_Py_Void();
21388 return resultobj;
21389 fail:
21390 return NULL;
21391 }
21392
21393
21394 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21395 PyObject *resultobj = 0;
21396 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21397 bool result;
21398 void *argp1 = 0 ;
21399 int res1 = 0 ;
21400 PyObject *swig_obj[1] ;
21401
21402 if (!args) SWIG_fail;
21403 swig_obj[0] = args;
21404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21405 if (!SWIG_IsOK(res1)) {
21406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21407 }
21408 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21409 result = (bool) ((arg1)->m_altDown);
21410 {
21411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21412 }
21413 return resultobj;
21414 fail:
21415 return NULL;
21416 }
21417
21418
21419 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21420 PyObject *resultobj = 0;
21421 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21422 bool arg2 ;
21423 void *argp1 = 0 ;
21424 int res1 = 0 ;
21425 bool val2 ;
21426 int ecode2 = 0 ;
21427 PyObject *swig_obj[2] ;
21428
21429 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21431 if (!SWIG_IsOK(res1)) {
21432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21433 }
21434 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21435 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21436 if (!SWIG_IsOK(ecode2)) {
21437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21438 }
21439 arg2 = static_cast< bool >(val2);
21440 if (arg1) (arg1)->m_metaDown = arg2;
21441
21442 resultobj = SWIG_Py_Void();
21443 return resultobj;
21444 fail:
21445 return NULL;
21446 }
21447
21448
21449 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21450 PyObject *resultobj = 0;
21451 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21452 bool result;
21453 void *argp1 = 0 ;
21454 int res1 = 0 ;
21455 PyObject *swig_obj[1] ;
21456
21457 if (!args) SWIG_fail;
21458 swig_obj[0] = args;
21459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21460 if (!SWIG_IsOK(res1)) {
21461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21462 }
21463 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21464 result = (bool) ((arg1)->m_metaDown);
21465 {
21466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21467 }
21468 return resultobj;
21469 fail:
21470 return NULL;
21471 }
21472
21473
21474 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21475 PyObject *resultobj = 0;
21476 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21477 int arg2 ;
21478 void *argp1 = 0 ;
21479 int res1 = 0 ;
21480 int val2 ;
21481 int ecode2 = 0 ;
21482 PyObject *swig_obj[2] ;
21483
21484 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21486 if (!SWIG_IsOK(res1)) {
21487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21488 }
21489 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21490 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21491 if (!SWIG_IsOK(ecode2)) {
21492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21493 }
21494 arg2 = static_cast< int >(val2);
21495 if (arg1) (arg1)->m_wheelRotation = arg2;
21496
21497 resultobj = SWIG_Py_Void();
21498 return resultobj;
21499 fail:
21500 return NULL;
21501 }
21502
21503
21504 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21505 PyObject *resultobj = 0;
21506 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21507 int result;
21508 void *argp1 = 0 ;
21509 int res1 = 0 ;
21510 PyObject *swig_obj[1] ;
21511
21512 if (!args) SWIG_fail;
21513 swig_obj[0] = args;
21514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21515 if (!SWIG_IsOK(res1)) {
21516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21517 }
21518 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21519 result = (int) ((arg1)->m_wheelRotation);
21520 resultobj = SWIG_From_int(static_cast< int >(result));
21521 return resultobj;
21522 fail:
21523 return NULL;
21524 }
21525
21526
21527 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21528 PyObject *resultobj = 0;
21529 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21530 int arg2 ;
21531 void *argp1 = 0 ;
21532 int res1 = 0 ;
21533 int val2 ;
21534 int ecode2 = 0 ;
21535 PyObject *swig_obj[2] ;
21536
21537 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21539 if (!SWIG_IsOK(res1)) {
21540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21541 }
21542 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21543 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21544 if (!SWIG_IsOK(ecode2)) {
21545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21546 }
21547 arg2 = static_cast< int >(val2);
21548 if (arg1) (arg1)->m_wheelDelta = arg2;
21549
21550 resultobj = SWIG_Py_Void();
21551 return resultobj;
21552 fail:
21553 return NULL;
21554 }
21555
21556
21557 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21558 PyObject *resultobj = 0;
21559 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21560 int result;
21561 void *argp1 = 0 ;
21562 int res1 = 0 ;
21563 PyObject *swig_obj[1] ;
21564
21565 if (!args) SWIG_fail;
21566 swig_obj[0] = args;
21567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21568 if (!SWIG_IsOK(res1)) {
21569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21570 }
21571 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21572 result = (int) ((arg1)->m_wheelDelta);
21573 resultobj = SWIG_From_int(static_cast< int >(result));
21574 return resultobj;
21575 fail:
21576 return NULL;
21577 }
21578
21579
21580 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21581 PyObject *resultobj = 0;
21582 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21583 int arg2 ;
21584 void *argp1 = 0 ;
21585 int res1 = 0 ;
21586 int val2 ;
21587 int ecode2 = 0 ;
21588 PyObject *swig_obj[2] ;
21589
21590 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21592 if (!SWIG_IsOK(res1)) {
21593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21594 }
21595 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21596 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21597 if (!SWIG_IsOK(ecode2)) {
21598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21599 }
21600 arg2 = static_cast< int >(val2);
21601 if (arg1) (arg1)->m_linesPerAction = arg2;
21602
21603 resultobj = SWIG_Py_Void();
21604 return resultobj;
21605 fail:
21606 return NULL;
21607 }
21608
21609
21610 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21611 PyObject *resultobj = 0;
21612 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21613 int result;
21614 void *argp1 = 0 ;
21615 int res1 = 0 ;
21616 PyObject *swig_obj[1] ;
21617
21618 if (!args) SWIG_fail;
21619 swig_obj[0] = args;
21620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21621 if (!SWIG_IsOK(res1)) {
21622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21623 }
21624 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21625 result = (int) ((arg1)->m_linesPerAction);
21626 resultobj = SWIG_From_int(static_cast< int >(result));
21627 return resultobj;
21628 fail:
21629 return NULL;
21630 }
21631
21632
21633 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21634 PyObject *obj;
21635 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21636 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21637 return SWIG_Py_Void();
21638 }
21639
21640 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21641 return SWIG_Python_InitShadowInstance(args);
21642 }
21643
21644 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21645 PyObject *resultobj = 0;
21646 int arg1 = (int) 0 ;
21647 int arg2 = (int) 0 ;
21648 wxSetCursorEvent *result = 0 ;
21649 int val1 ;
21650 int ecode1 = 0 ;
21651 int val2 ;
21652 int ecode2 = 0 ;
21653 PyObject * obj0 = 0 ;
21654 PyObject * obj1 = 0 ;
21655 char * kwnames[] = {
21656 (char *) "x",(char *) "y", NULL
21657 };
21658
21659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21660 if (obj0) {
21661 ecode1 = SWIG_AsVal_int(obj0, &val1);
21662 if (!SWIG_IsOK(ecode1)) {
21663 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21664 }
21665 arg1 = static_cast< int >(val1);
21666 }
21667 if (obj1) {
21668 ecode2 = SWIG_AsVal_int(obj1, &val2);
21669 if (!SWIG_IsOK(ecode2)) {
21670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21671 }
21672 arg2 = static_cast< int >(val2);
21673 }
21674 {
21675 PyThreadState* __tstate = wxPyBeginAllowThreads();
21676 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21677 wxPyEndAllowThreads(__tstate);
21678 if (PyErr_Occurred()) SWIG_fail;
21679 }
21680 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21681 return resultobj;
21682 fail:
21683 return NULL;
21684 }
21685
21686
21687 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21688 PyObject *resultobj = 0;
21689 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 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_wxSetCursorEvent, 0 | 0 );
21698 if (!SWIG_IsOK(res1)) {
21699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21700 }
21701 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21702 {
21703 PyThreadState* __tstate = wxPyBeginAllowThreads();
21704 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
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_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21716 PyObject *resultobj = 0;
21717 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21718 int 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_wxSetCursorEvent, 0 | 0 );
21726 if (!SWIG_IsOK(res1)) {
21727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21728 }
21729 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21730 {
21731 PyThreadState* __tstate = wxPyBeginAllowThreads();
21732 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21733 wxPyEndAllowThreads(__tstate);
21734 if (PyErr_Occurred()) SWIG_fail;
21735 }
21736 resultobj = SWIG_From_int(static_cast< int >(result));
21737 return resultobj;
21738 fail:
21739 return NULL;
21740 }
21741
21742
21743 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21744 PyObject *resultobj = 0;
21745 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21746 wxCursor *arg2 = 0 ;
21747 void *argp1 = 0 ;
21748 int res1 = 0 ;
21749 void *argp2 = 0 ;
21750 int res2 = 0 ;
21751 PyObject * obj0 = 0 ;
21752 PyObject * obj1 = 0 ;
21753 char * kwnames[] = {
21754 (char *) "self",(char *) "cursor", NULL
21755 };
21756
21757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21759 if (!SWIG_IsOK(res1)) {
21760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21761 }
21762 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21763 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21764 if (!SWIG_IsOK(res2)) {
21765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21766 }
21767 if (!argp2) {
21768 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21769 }
21770 arg2 = reinterpret_cast< wxCursor * >(argp2);
21771 {
21772 PyThreadState* __tstate = wxPyBeginAllowThreads();
21773 (arg1)->SetCursor((wxCursor const &)*arg2);
21774 wxPyEndAllowThreads(__tstate);
21775 if (PyErr_Occurred()) SWIG_fail;
21776 }
21777 resultobj = SWIG_Py_Void();
21778 return resultobj;
21779 fail:
21780 return NULL;
21781 }
21782
21783
21784 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21785 PyObject *resultobj = 0;
21786 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21787 wxCursor *result = 0 ;
21788 void *argp1 = 0 ;
21789 int res1 = 0 ;
21790 PyObject *swig_obj[1] ;
21791
21792 if (!args) SWIG_fail;
21793 swig_obj[0] = args;
21794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21795 if (!SWIG_IsOK(res1)) {
21796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21797 }
21798 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21799 {
21800 PyThreadState* __tstate = wxPyBeginAllowThreads();
21801 {
21802 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21803 result = (wxCursor *) &_result_ref;
21804 }
21805 wxPyEndAllowThreads(__tstate);
21806 if (PyErr_Occurred()) SWIG_fail;
21807 }
21808 {
21809 wxCursor* resultptr = new wxCursor(*result);
21810 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21811 }
21812 return resultobj;
21813 fail:
21814 return NULL;
21815 }
21816
21817
21818 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21819 PyObject *resultobj = 0;
21820 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21821 bool result;
21822 void *argp1 = 0 ;
21823 int res1 = 0 ;
21824 PyObject *swig_obj[1] ;
21825
21826 if (!args) SWIG_fail;
21827 swig_obj[0] = args;
21828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21829 if (!SWIG_IsOK(res1)) {
21830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21831 }
21832 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21833 {
21834 PyThreadState* __tstate = wxPyBeginAllowThreads();
21835 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21836 wxPyEndAllowThreads(__tstate);
21837 if (PyErr_Occurred()) SWIG_fail;
21838 }
21839 {
21840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21841 }
21842 return resultobj;
21843 fail:
21844 return NULL;
21845 }
21846
21847
21848 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21849 PyObject *obj;
21850 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21851 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21852 return SWIG_Py_Void();
21853 }
21854
21855 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21856 return SWIG_Python_InitShadowInstance(args);
21857 }
21858
21859 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21860 PyObject *resultobj = 0;
21861 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21862 wxKeyEvent *result = 0 ;
21863 int val1 ;
21864 int ecode1 = 0 ;
21865 PyObject * obj0 = 0 ;
21866 char * kwnames[] = {
21867 (char *) "eventType", NULL
21868 };
21869
21870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21871 if (obj0) {
21872 ecode1 = SWIG_AsVal_int(obj0, &val1);
21873 if (!SWIG_IsOK(ecode1)) {
21874 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21875 }
21876 arg1 = static_cast< wxEventType >(val1);
21877 }
21878 {
21879 PyThreadState* __tstate = wxPyBeginAllowThreads();
21880 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21881 wxPyEndAllowThreads(__tstate);
21882 if (PyErr_Occurred()) SWIG_fail;
21883 }
21884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21885 return resultobj;
21886 fail:
21887 return NULL;
21888 }
21889
21890
21891 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21892 PyObject *resultobj = 0;
21893 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21894 int result;
21895 void *argp1 = 0 ;
21896 int res1 = 0 ;
21897 PyObject *swig_obj[1] ;
21898
21899 if (!args) SWIG_fail;
21900 swig_obj[0] = args;
21901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21902 if (!SWIG_IsOK(res1)) {
21903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21904 }
21905 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21906 {
21907 PyThreadState* __tstate = wxPyBeginAllowThreads();
21908 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21909 wxPyEndAllowThreads(__tstate);
21910 if (PyErr_Occurred()) SWIG_fail;
21911 }
21912 resultobj = SWIG_From_int(static_cast< int >(result));
21913 return resultobj;
21914 fail:
21915 return NULL;
21916 }
21917
21918
21919 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21920 PyObject *resultobj = 0;
21921 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21922 bool result;
21923 void *argp1 = 0 ;
21924 int res1 = 0 ;
21925 PyObject *swig_obj[1] ;
21926
21927 if (!args) SWIG_fail;
21928 swig_obj[0] = args;
21929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21930 if (!SWIG_IsOK(res1)) {
21931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21932 }
21933 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21934 {
21935 PyThreadState* __tstate = wxPyBeginAllowThreads();
21936 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21937 wxPyEndAllowThreads(__tstate);
21938 if (PyErr_Occurred()) SWIG_fail;
21939 }
21940 {
21941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21942 }
21943 return resultobj;
21944 fail:
21945 return NULL;
21946 }
21947
21948
21949 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21950 PyObject *resultobj = 0;
21951 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21952 bool result;
21953 void *argp1 = 0 ;
21954 int res1 = 0 ;
21955 PyObject *swig_obj[1] ;
21956
21957 if (!args) SWIG_fail;
21958 swig_obj[0] = args;
21959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21960 if (!SWIG_IsOK(res1)) {
21961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21962 }
21963 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21964 {
21965 PyThreadState* __tstate = wxPyBeginAllowThreads();
21966 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21967 wxPyEndAllowThreads(__tstate);
21968 if (PyErr_Occurred()) SWIG_fail;
21969 }
21970 {
21971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21972 }
21973 return resultobj;
21974 fail:
21975 return NULL;
21976 }
21977
21978
21979 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21980 PyObject *resultobj = 0;
21981 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21982 bool result;
21983 void *argp1 = 0 ;
21984 int res1 = 0 ;
21985 PyObject *swig_obj[1] ;
21986
21987 if (!args) SWIG_fail;
21988 swig_obj[0] = args;
21989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21990 if (!SWIG_IsOK(res1)) {
21991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21992 }
21993 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21994 {
21995 PyThreadState* __tstate = wxPyBeginAllowThreads();
21996 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21997 wxPyEndAllowThreads(__tstate);
21998 if (PyErr_Occurred()) SWIG_fail;
21999 }
22000 {
22001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22002 }
22003 return resultobj;
22004 fail:
22005 return NULL;
22006 }
22007
22008
22009 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22010 PyObject *resultobj = 0;
22011 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22012 bool result;
22013 void *argp1 = 0 ;
22014 int res1 = 0 ;
22015 PyObject *swig_obj[1] ;
22016
22017 if (!args) SWIG_fail;
22018 swig_obj[0] = args;
22019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22020 if (!SWIG_IsOK(res1)) {
22021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22022 }
22023 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22024 {
22025 PyThreadState* __tstate = wxPyBeginAllowThreads();
22026 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22027 wxPyEndAllowThreads(__tstate);
22028 if (PyErr_Occurred()) SWIG_fail;
22029 }
22030 {
22031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22032 }
22033 return resultobj;
22034 fail:
22035 return NULL;
22036 }
22037
22038
22039 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22040 PyObject *resultobj = 0;
22041 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22042 bool result;
22043 void *argp1 = 0 ;
22044 int res1 = 0 ;
22045 PyObject *swig_obj[1] ;
22046
22047 if (!args) SWIG_fail;
22048 swig_obj[0] = args;
22049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22050 if (!SWIG_IsOK(res1)) {
22051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22052 }
22053 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22054 {
22055 PyThreadState* __tstate = wxPyBeginAllowThreads();
22056 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22057 wxPyEndAllowThreads(__tstate);
22058 if (PyErr_Occurred()) SWIG_fail;
22059 }
22060 {
22061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22062 }
22063 return resultobj;
22064 fail:
22065 return NULL;
22066 }
22067
22068
22069 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22070 PyObject *resultobj = 0;
22071 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22072 bool result;
22073 void *argp1 = 0 ;
22074 int res1 = 0 ;
22075 PyObject *swig_obj[1] ;
22076
22077 if (!args) SWIG_fail;
22078 swig_obj[0] = args;
22079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22080 if (!SWIG_IsOK(res1)) {
22081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22082 }
22083 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22084 {
22085 PyThreadState* __tstate = wxPyBeginAllowThreads();
22086 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22087 wxPyEndAllowThreads(__tstate);
22088 if (PyErr_Occurred()) SWIG_fail;
22089 }
22090 {
22091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22092 }
22093 return resultobj;
22094 fail:
22095 return NULL;
22096 }
22097
22098
22099 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22100 PyObject *resultobj = 0;
22101 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22102 int result;
22103 void *argp1 = 0 ;
22104 int res1 = 0 ;
22105 PyObject *swig_obj[1] ;
22106
22107 if (!args) SWIG_fail;
22108 swig_obj[0] = args;
22109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22110 if (!SWIG_IsOK(res1)) {
22111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22112 }
22113 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22114 {
22115 PyThreadState* __tstate = wxPyBeginAllowThreads();
22116 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22117 wxPyEndAllowThreads(__tstate);
22118 if (PyErr_Occurred()) SWIG_fail;
22119 }
22120 resultobj = SWIG_From_int(static_cast< int >(result));
22121 return resultobj;
22122 fail:
22123 return NULL;
22124 }
22125
22126
22127 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22128 PyObject *resultobj = 0;
22129 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22130 int result;
22131 void *argp1 = 0 ;
22132 int res1 = 0 ;
22133 PyObject *swig_obj[1] ;
22134
22135 if (!args) SWIG_fail;
22136 swig_obj[0] = args;
22137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22138 if (!SWIG_IsOK(res1)) {
22139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22140 }
22141 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22142 {
22143 PyThreadState* __tstate = wxPyBeginAllowThreads();
22144 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22145 wxPyEndAllowThreads(__tstate);
22146 if (PyErr_Occurred()) SWIG_fail;
22147 }
22148 resultobj = SWIG_From_int(static_cast< int >(result));
22149 return resultobj;
22150 fail:
22151 return NULL;
22152 }
22153
22154
22155 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22156 PyObject *resultobj = 0;
22157 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22158 int arg2 ;
22159 void *argp1 = 0 ;
22160 int res1 = 0 ;
22161 int val2 ;
22162 int ecode2 = 0 ;
22163 PyObject * obj0 = 0 ;
22164 PyObject * obj1 = 0 ;
22165 char * kwnames[] = {
22166 (char *) "self",(char *) "uniChar", NULL
22167 };
22168
22169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22171 if (!SWIG_IsOK(res1)) {
22172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22173 }
22174 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22175 ecode2 = SWIG_AsVal_int(obj1, &val2);
22176 if (!SWIG_IsOK(ecode2)) {
22177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22178 }
22179 arg2 = static_cast< int >(val2);
22180 {
22181 PyThreadState* __tstate = wxPyBeginAllowThreads();
22182 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22183 wxPyEndAllowThreads(__tstate);
22184 if (PyErr_Occurred()) SWIG_fail;
22185 }
22186 resultobj = SWIG_Py_Void();
22187 return resultobj;
22188 fail:
22189 return NULL;
22190 }
22191
22192
22193 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22194 PyObject *resultobj = 0;
22195 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22196 unsigned int result;
22197 void *argp1 = 0 ;
22198 int res1 = 0 ;
22199 PyObject *swig_obj[1] ;
22200
22201 if (!args) SWIG_fail;
22202 swig_obj[0] = args;
22203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22204 if (!SWIG_IsOK(res1)) {
22205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22206 }
22207 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22208 {
22209 PyThreadState* __tstate = wxPyBeginAllowThreads();
22210 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22211 wxPyEndAllowThreads(__tstate);
22212 if (PyErr_Occurred()) SWIG_fail;
22213 }
22214 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22215 return resultobj;
22216 fail:
22217 return NULL;
22218 }
22219
22220
22221 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22222 PyObject *resultobj = 0;
22223 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22224 unsigned int result;
22225 void *argp1 = 0 ;
22226 int res1 = 0 ;
22227 PyObject *swig_obj[1] ;
22228
22229 if (!args) SWIG_fail;
22230 swig_obj[0] = args;
22231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22232 if (!SWIG_IsOK(res1)) {
22233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22234 }
22235 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22236 {
22237 PyThreadState* __tstate = wxPyBeginAllowThreads();
22238 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22239 wxPyEndAllowThreads(__tstate);
22240 if (PyErr_Occurred()) SWIG_fail;
22241 }
22242 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22243 return resultobj;
22244 fail:
22245 return NULL;
22246 }
22247
22248
22249 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22250 PyObject *resultobj = 0;
22251 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22252 wxPoint result;
22253 void *argp1 = 0 ;
22254 int res1 = 0 ;
22255 PyObject *swig_obj[1] ;
22256
22257 if (!args) SWIG_fail;
22258 swig_obj[0] = args;
22259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22260 if (!SWIG_IsOK(res1)) {
22261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22262 }
22263 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22264 {
22265 PyThreadState* __tstate = wxPyBeginAllowThreads();
22266 result = (arg1)->GetPosition();
22267 wxPyEndAllowThreads(__tstate);
22268 if (PyErr_Occurred()) SWIG_fail;
22269 }
22270 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22271 return resultobj;
22272 fail:
22273 return NULL;
22274 }
22275
22276
22277 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22278 PyObject *resultobj = 0;
22279 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22280 long *arg2 = (long *) 0 ;
22281 long *arg3 = (long *) 0 ;
22282 void *argp1 = 0 ;
22283 int res1 = 0 ;
22284 long temp2 ;
22285 int res2 = SWIG_TMPOBJ ;
22286 long temp3 ;
22287 int res3 = SWIG_TMPOBJ ;
22288 PyObject *swig_obj[1] ;
22289
22290 arg2 = &temp2;
22291 arg3 = &temp3;
22292 if (!args) SWIG_fail;
22293 swig_obj[0] = args;
22294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22295 if (!SWIG_IsOK(res1)) {
22296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22297 }
22298 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22299 {
22300 PyThreadState* __tstate = wxPyBeginAllowThreads();
22301 (arg1)->GetPosition(arg2,arg3);
22302 wxPyEndAllowThreads(__tstate);
22303 if (PyErr_Occurred()) SWIG_fail;
22304 }
22305 resultobj = SWIG_Py_Void();
22306 if (SWIG_IsTmpObj(res2)) {
22307 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22308 } else {
22309 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22310 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22311 }
22312 if (SWIG_IsTmpObj(res3)) {
22313 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22314 } else {
22315 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22316 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22317 }
22318 return resultobj;
22319 fail:
22320 return NULL;
22321 }
22322
22323
22324 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22325 PyObject *resultobj = 0;
22326 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22327 int result;
22328 void *argp1 = 0 ;
22329 int res1 = 0 ;
22330 PyObject *swig_obj[1] ;
22331
22332 if (!args) SWIG_fail;
22333 swig_obj[0] = args;
22334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22335 if (!SWIG_IsOK(res1)) {
22336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22337 }
22338 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22339 {
22340 PyThreadState* __tstate = wxPyBeginAllowThreads();
22341 result = (int)((wxKeyEvent const *)arg1)->GetX();
22342 wxPyEndAllowThreads(__tstate);
22343 if (PyErr_Occurred()) SWIG_fail;
22344 }
22345 resultobj = SWIG_From_int(static_cast< int >(result));
22346 return resultobj;
22347 fail:
22348 return NULL;
22349 }
22350
22351
22352 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22353 PyObject *resultobj = 0;
22354 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22355 int result;
22356 void *argp1 = 0 ;
22357 int res1 = 0 ;
22358 PyObject *swig_obj[1] ;
22359
22360 if (!args) SWIG_fail;
22361 swig_obj[0] = args;
22362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22363 if (!SWIG_IsOK(res1)) {
22364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22365 }
22366 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22367 {
22368 PyThreadState* __tstate = wxPyBeginAllowThreads();
22369 result = (int)((wxKeyEvent const *)arg1)->GetY();
22370 wxPyEndAllowThreads(__tstate);
22371 if (PyErr_Occurred()) SWIG_fail;
22372 }
22373 resultobj = SWIG_From_int(static_cast< int >(result));
22374 return resultobj;
22375 fail:
22376 return NULL;
22377 }
22378
22379
22380 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22381 PyObject *resultobj = 0;
22382 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22383 int arg2 ;
22384 void *argp1 = 0 ;
22385 int res1 = 0 ;
22386 int val2 ;
22387 int ecode2 = 0 ;
22388 PyObject *swig_obj[2] ;
22389
22390 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22392 if (!SWIG_IsOK(res1)) {
22393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22394 }
22395 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22396 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22397 if (!SWIG_IsOK(ecode2)) {
22398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22399 }
22400 arg2 = static_cast< int >(val2);
22401 if (arg1) (arg1)->m_x = arg2;
22402
22403 resultobj = SWIG_Py_Void();
22404 return resultobj;
22405 fail:
22406 return NULL;
22407 }
22408
22409
22410 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22411 PyObject *resultobj = 0;
22412 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22413 int result;
22414 void *argp1 = 0 ;
22415 int res1 = 0 ;
22416 PyObject *swig_obj[1] ;
22417
22418 if (!args) SWIG_fail;
22419 swig_obj[0] = args;
22420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22421 if (!SWIG_IsOK(res1)) {
22422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22423 }
22424 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22425 result = (int) ((arg1)->m_x);
22426 resultobj = SWIG_From_int(static_cast< int >(result));
22427 return resultobj;
22428 fail:
22429 return NULL;
22430 }
22431
22432
22433 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22434 PyObject *resultobj = 0;
22435 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22436 int arg2 ;
22437 void *argp1 = 0 ;
22438 int res1 = 0 ;
22439 int val2 ;
22440 int ecode2 = 0 ;
22441 PyObject *swig_obj[2] ;
22442
22443 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22445 if (!SWIG_IsOK(res1)) {
22446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22447 }
22448 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22449 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22450 if (!SWIG_IsOK(ecode2)) {
22451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22452 }
22453 arg2 = static_cast< int >(val2);
22454 if (arg1) (arg1)->m_y = arg2;
22455
22456 resultobj = SWIG_Py_Void();
22457 return resultobj;
22458 fail:
22459 return NULL;
22460 }
22461
22462
22463 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22464 PyObject *resultobj = 0;
22465 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22466 int result;
22467 void *argp1 = 0 ;
22468 int res1 = 0 ;
22469 PyObject *swig_obj[1] ;
22470
22471 if (!args) SWIG_fail;
22472 swig_obj[0] = args;
22473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22474 if (!SWIG_IsOK(res1)) {
22475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22476 }
22477 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22478 result = (int) ((arg1)->m_y);
22479 resultobj = SWIG_From_int(static_cast< int >(result));
22480 return resultobj;
22481 fail:
22482 return NULL;
22483 }
22484
22485
22486 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22487 PyObject *resultobj = 0;
22488 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22489 long arg2 ;
22490 void *argp1 = 0 ;
22491 int res1 = 0 ;
22492 long val2 ;
22493 int ecode2 = 0 ;
22494 PyObject *swig_obj[2] ;
22495
22496 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22498 if (!SWIG_IsOK(res1)) {
22499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22500 }
22501 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22502 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22503 if (!SWIG_IsOK(ecode2)) {
22504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22505 }
22506 arg2 = static_cast< long >(val2);
22507 if (arg1) (arg1)->m_keyCode = arg2;
22508
22509 resultobj = SWIG_Py_Void();
22510 return resultobj;
22511 fail:
22512 return NULL;
22513 }
22514
22515
22516 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22517 PyObject *resultobj = 0;
22518 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22519 long result;
22520 void *argp1 = 0 ;
22521 int res1 = 0 ;
22522 PyObject *swig_obj[1] ;
22523
22524 if (!args) SWIG_fail;
22525 swig_obj[0] = args;
22526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22527 if (!SWIG_IsOK(res1)) {
22528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22529 }
22530 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22531 result = (long) ((arg1)->m_keyCode);
22532 resultobj = SWIG_From_long(static_cast< long >(result));
22533 return resultobj;
22534 fail:
22535 return NULL;
22536 }
22537
22538
22539 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22540 PyObject *resultobj = 0;
22541 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22542 bool arg2 ;
22543 void *argp1 = 0 ;
22544 int res1 = 0 ;
22545 bool val2 ;
22546 int ecode2 = 0 ;
22547 PyObject *swig_obj[2] ;
22548
22549 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22551 if (!SWIG_IsOK(res1)) {
22552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22553 }
22554 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22555 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22556 if (!SWIG_IsOK(ecode2)) {
22557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22558 }
22559 arg2 = static_cast< bool >(val2);
22560 if (arg1) (arg1)->m_controlDown = arg2;
22561
22562 resultobj = SWIG_Py_Void();
22563 return resultobj;
22564 fail:
22565 return NULL;
22566 }
22567
22568
22569 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22570 PyObject *resultobj = 0;
22571 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22572 bool result;
22573 void *argp1 = 0 ;
22574 int res1 = 0 ;
22575 PyObject *swig_obj[1] ;
22576
22577 if (!args) SWIG_fail;
22578 swig_obj[0] = args;
22579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22580 if (!SWIG_IsOK(res1)) {
22581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22582 }
22583 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22584 result = (bool) ((arg1)->m_controlDown);
22585 {
22586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22587 }
22588 return resultobj;
22589 fail:
22590 return NULL;
22591 }
22592
22593
22594 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22595 PyObject *resultobj = 0;
22596 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22597 bool arg2 ;
22598 void *argp1 = 0 ;
22599 int res1 = 0 ;
22600 bool val2 ;
22601 int ecode2 = 0 ;
22602 PyObject *swig_obj[2] ;
22603
22604 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22606 if (!SWIG_IsOK(res1)) {
22607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22608 }
22609 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22610 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22611 if (!SWIG_IsOK(ecode2)) {
22612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22613 }
22614 arg2 = static_cast< bool >(val2);
22615 if (arg1) (arg1)->m_shiftDown = arg2;
22616
22617 resultobj = SWIG_Py_Void();
22618 return resultobj;
22619 fail:
22620 return NULL;
22621 }
22622
22623
22624 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22625 PyObject *resultobj = 0;
22626 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22627 bool result;
22628 void *argp1 = 0 ;
22629 int res1 = 0 ;
22630 PyObject *swig_obj[1] ;
22631
22632 if (!args) SWIG_fail;
22633 swig_obj[0] = args;
22634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22635 if (!SWIG_IsOK(res1)) {
22636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22637 }
22638 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22639 result = (bool) ((arg1)->m_shiftDown);
22640 {
22641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22642 }
22643 return resultobj;
22644 fail:
22645 return NULL;
22646 }
22647
22648
22649 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22650 PyObject *resultobj = 0;
22651 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22652 bool arg2 ;
22653 void *argp1 = 0 ;
22654 int res1 = 0 ;
22655 bool val2 ;
22656 int ecode2 = 0 ;
22657 PyObject *swig_obj[2] ;
22658
22659 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22661 if (!SWIG_IsOK(res1)) {
22662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22663 }
22664 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22665 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22666 if (!SWIG_IsOK(ecode2)) {
22667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22668 }
22669 arg2 = static_cast< bool >(val2);
22670 if (arg1) (arg1)->m_altDown = arg2;
22671
22672 resultobj = SWIG_Py_Void();
22673 return resultobj;
22674 fail:
22675 return NULL;
22676 }
22677
22678
22679 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22680 PyObject *resultobj = 0;
22681 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22682 bool result;
22683 void *argp1 = 0 ;
22684 int res1 = 0 ;
22685 PyObject *swig_obj[1] ;
22686
22687 if (!args) SWIG_fail;
22688 swig_obj[0] = args;
22689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22690 if (!SWIG_IsOK(res1)) {
22691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22692 }
22693 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22694 result = (bool) ((arg1)->m_altDown);
22695 {
22696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22697 }
22698 return resultobj;
22699 fail:
22700 return NULL;
22701 }
22702
22703
22704 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22705 PyObject *resultobj = 0;
22706 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22707 bool arg2 ;
22708 void *argp1 = 0 ;
22709 int res1 = 0 ;
22710 bool val2 ;
22711 int ecode2 = 0 ;
22712 PyObject *swig_obj[2] ;
22713
22714 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22716 if (!SWIG_IsOK(res1)) {
22717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22718 }
22719 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22720 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22721 if (!SWIG_IsOK(ecode2)) {
22722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22723 }
22724 arg2 = static_cast< bool >(val2);
22725 if (arg1) (arg1)->m_metaDown = arg2;
22726
22727 resultobj = SWIG_Py_Void();
22728 return resultobj;
22729 fail:
22730 return NULL;
22731 }
22732
22733
22734 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22735 PyObject *resultobj = 0;
22736 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22737 bool result;
22738 void *argp1 = 0 ;
22739 int res1 = 0 ;
22740 PyObject *swig_obj[1] ;
22741
22742 if (!args) SWIG_fail;
22743 swig_obj[0] = args;
22744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22745 if (!SWIG_IsOK(res1)) {
22746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22747 }
22748 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22749 result = (bool) ((arg1)->m_metaDown);
22750 {
22751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22752 }
22753 return resultobj;
22754 fail:
22755 return NULL;
22756 }
22757
22758
22759 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22760 PyObject *resultobj = 0;
22761 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22762 bool arg2 ;
22763 void *argp1 = 0 ;
22764 int res1 = 0 ;
22765 bool val2 ;
22766 int ecode2 = 0 ;
22767 PyObject *swig_obj[2] ;
22768
22769 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22771 if (!SWIG_IsOK(res1)) {
22772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22773 }
22774 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22775 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22776 if (!SWIG_IsOK(ecode2)) {
22777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22778 }
22779 arg2 = static_cast< bool >(val2);
22780 if (arg1) (arg1)->m_scanCode = arg2;
22781
22782 resultobj = SWIG_Py_Void();
22783 return resultobj;
22784 fail:
22785 return NULL;
22786 }
22787
22788
22789 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22790 PyObject *resultobj = 0;
22791 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22792 bool result;
22793 void *argp1 = 0 ;
22794 int res1 = 0 ;
22795 PyObject *swig_obj[1] ;
22796
22797 if (!args) SWIG_fail;
22798 swig_obj[0] = args;
22799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22800 if (!SWIG_IsOK(res1)) {
22801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22802 }
22803 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22804 result = (bool) ((arg1)->m_scanCode);
22805 {
22806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22807 }
22808 return resultobj;
22809 fail:
22810 return NULL;
22811 }
22812
22813
22814 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22815 PyObject *resultobj = 0;
22816 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22817 unsigned int arg2 ;
22818 void *argp1 = 0 ;
22819 int res1 = 0 ;
22820 unsigned int val2 ;
22821 int ecode2 = 0 ;
22822 PyObject *swig_obj[2] ;
22823
22824 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22826 if (!SWIG_IsOK(res1)) {
22827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22828 }
22829 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22830 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22831 if (!SWIG_IsOK(ecode2)) {
22832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22833 }
22834 arg2 = static_cast< unsigned int >(val2);
22835 if (arg1) (arg1)->m_rawCode = arg2;
22836
22837 resultobj = SWIG_Py_Void();
22838 return resultobj;
22839 fail:
22840 return NULL;
22841 }
22842
22843
22844 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22845 PyObject *resultobj = 0;
22846 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22847 unsigned int result;
22848 void *argp1 = 0 ;
22849 int res1 = 0 ;
22850 PyObject *swig_obj[1] ;
22851
22852 if (!args) SWIG_fail;
22853 swig_obj[0] = args;
22854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22855 if (!SWIG_IsOK(res1)) {
22856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22857 }
22858 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22859 result = (unsigned int) ((arg1)->m_rawCode);
22860 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22861 return resultobj;
22862 fail:
22863 return NULL;
22864 }
22865
22866
22867 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22868 PyObject *resultobj = 0;
22869 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22870 unsigned int arg2 ;
22871 void *argp1 = 0 ;
22872 int res1 = 0 ;
22873 unsigned int val2 ;
22874 int ecode2 = 0 ;
22875 PyObject *swig_obj[2] ;
22876
22877 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22879 if (!SWIG_IsOK(res1)) {
22880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22881 }
22882 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22883 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22884 if (!SWIG_IsOK(ecode2)) {
22885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22886 }
22887 arg2 = static_cast< unsigned int >(val2);
22888 if (arg1) (arg1)->m_rawFlags = arg2;
22889
22890 resultobj = SWIG_Py_Void();
22891 return resultobj;
22892 fail:
22893 return NULL;
22894 }
22895
22896
22897 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22898 PyObject *resultobj = 0;
22899 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22900 unsigned int result;
22901 void *argp1 = 0 ;
22902 int res1 = 0 ;
22903 PyObject *swig_obj[1] ;
22904
22905 if (!args) SWIG_fail;
22906 swig_obj[0] = args;
22907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22908 if (!SWIG_IsOK(res1)) {
22909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22910 }
22911 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22912 result = (unsigned int) ((arg1)->m_rawFlags);
22913 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22914 return resultobj;
22915 fail:
22916 return NULL;
22917 }
22918
22919
22920 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22921 PyObject *obj;
22922 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22923 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22924 return SWIG_Py_Void();
22925 }
22926
22927 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22928 return SWIG_Python_InitShadowInstance(args);
22929 }
22930
22931 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22932 PyObject *resultobj = 0;
22933 wxSize const &arg1_defvalue = wxDefaultSize ;
22934 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22935 int arg2 = (int) 0 ;
22936 wxSizeEvent *result = 0 ;
22937 wxSize temp1 ;
22938 int val2 ;
22939 int ecode2 = 0 ;
22940 PyObject * obj0 = 0 ;
22941 PyObject * obj1 = 0 ;
22942 char * kwnames[] = {
22943 (char *) "sz",(char *) "winid", NULL
22944 };
22945
22946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22947 if (obj0) {
22948 {
22949 arg1 = &temp1;
22950 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22951 }
22952 }
22953 if (obj1) {
22954 ecode2 = SWIG_AsVal_int(obj1, &val2);
22955 if (!SWIG_IsOK(ecode2)) {
22956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22957 }
22958 arg2 = static_cast< int >(val2);
22959 }
22960 {
22961 PyThreadState* __tstate = wxPyBeginAllowThreads();
22962 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22963 wxPyEndAllowThreads(__tstate);
22964 if (PyErr_Occurred()) SWIG_fail;
22965 }
22966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22967 return resultobj;
22968 fail:
22969 return NULL;
22970 }
22971
22972
22973 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22974 PyObject *resultobj = 0;
22975 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22976 wxSize result;
22977 void *argp1 = 0 ;
22978 int res1 = 0 ;
22979 PyObject *swig_obj[1] ;
22980
22981 if (!args) SWIG_fail;
22982 swig_obj[0] = args;
22983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22984 if (!SWIG_IsOK(res1)) {
22985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22986 }
22987 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22988 {
22989 PyThreadState* __tstate = wxPyBeginAllowThreads();
22990 result = ((wxSizeEvent const *)arg1)->GetSize();
22991 wxPyEndAllowThreads(__tstate);
22992 if (PyErr_Occurred()) SWIG_fail;
22993 }
22994 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22995 return resultobj;
22996 fail:
22997 return NULL;
22998 }
22999
23000
23001 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23002 PyObject *resultobj = 0;
23003 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23004 wxRect result;
23005 void *argp1 = 0 ;
23006 int res1 = 0 ;
23007 PyObject *swig_obj[1] ;
23008
23009 if (!args) SWIG_fail;
23010 swig_obj[0] = args;
23011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23012 if (!SWIG_IsOK(res1)) {
23013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23014 }
23015 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23016 {
23017 PyThreadState* __tstate = wxPyBeginAllowThreads();
23018 result = ((wxSizeEvent const *)arg1)->GetRect();
23019 wxPyEndAllowThreads(__tstate);
23020 if (PyErr_Occurred()) SWIG_fail;
23021 }
23022 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23023 return resultobj;
23024 fail:
23025 return NULL;
23026 }
23027
23028
23029 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23030 PyObject *resultobj = 0;
23031 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23032 wxRect arg2 ;
23033 void *argp1 = 0 ;
23034 int res1 = 0 ;
23035 void *argp2 ;
23036 int res2 = 0 ;
23037 PyObject * obj0 = 0 ;
23038 PyObject * obj1 = 0 ;
23039 char * kwnames[] = {
23040 (char *) "self",(char *) "rect", NULL
23041 };
23042
23043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23045 if (!SWIG_IsOK(res1)) {
23046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23047 }
23048 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23049 {
23050 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23051 if (!SWIG_IsOK(res2)) {
23052 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23053 }
23054 if (!argp2) {
23055 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23056 } else {
23057 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23058 arg2 = *temp;
23059 if (SWIG_IsNewObj(res2)) delete temp;
23060 }
23061 }
23062 {
23063 PyThreadState* __tstate = wxPyBeginAllowThreads();
23064 (arg1)->SetRect(arg2);
23065 wxPyEndAllowThreads(__tstate);
23066 if (PyErr_Occurred()) SWIG_fail;
23067 }
23068 resultobj = SWIG_Py_Void();
23069 return resultobj;
23070 fail:
23071 return NULL;
23072 }
23073
23074
23075 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23076 PyObject *resultobj = 0;
23077 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23078 wxSize arg2 ;
23079 void *argp1 = 0 ;
23080 int res1 = 0 ;
23081 void *argp2 ;
23082 int res2 = 0 ;
23083 PyObject * obj0 = 0 ;
23084 PyObject * obj1 = 0 ;
23085 char * kwnames[] = {
23086 (char *) "self",(char *) "size", NULL
23087 };
23088
23089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23091 if (!SWIG_IsOK(res1)) {
23092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23093 }
23094 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23095 {
23096 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23097 if (!SWIG_IsOK(res2)) {
23098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23099 }
23100 if (!argp2) {
23101 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23102 } else {
23103 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23104 arg2 = *temp;
23105 if (SWIG_IsNewObj(res2)) delete temp;
23106 }
23107 }
23108 {
23109 PyThreadState* __tstate = wxPyBeginAllowThreads();
23110 wxSizeEvent_SetSize(arg1,arg2);
23111 wxPyEndAllowThreads(__tstate);
23112 if (PyErr_Occurred()) SWIG_fail;
23113 }
23114 resultobj = SWIG_Py_Void();
23115 return resultobj;
23116 fail:
23117 return NULL;
23118 }
23119
23120
23121 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23122 PyObject *resultobj = 0;
23123 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23124 wxSize *arg2 = (wxSize *) 0 ;
23125 void *argp1 = 0 ;
23126 int res1 = 0 ;
23127 void *argp2 = 0 ;
23128 int res2 = 0 ;
23129 PyObject *swig_obj[2] ;
23130
23131 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23133 if (!SWIG_IsOK(res1)) {
23134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23135 }
23136 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23137 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23138 if (!SWIG_IsOK(res2)) {
23139 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23140 }
23141 arg2 = reinterpret_cast< wxSize * >(argp2);
23142 if (arg1) (arg1)->m_size = *arg2;
23143
23144 resultobj = SWIG_Py_Void();
23145 return resultobj;
23146 fail:
23147 return NULL;
23148 }
23149
23150
23151 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23152 PyObject *resultobj = 0;
23153 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23154 wxSize *result = 0 ;
23155 void *argp1 = 0 ;
23156 int res1 = 0 ;
23157 PyObject *swig_obj[1] ;
23158
23159 if (!args) SWIG_fail;
23160 swig_obj[0] = args;
23161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23162 if (!SWIG_IsOK(res1)) {
23163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23164 }
23165 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23166 result = (wxSize *)& ((arg1)->m_size);
23167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23168 return resultobj;
23169 fail:
23170 return NULL;
23171 }
23172
23173
23174 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23175 PyObject *resultobj = 0;
23176 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23177 wxRect *arg2 = (wxRect *) 0 ;
23178 void *argp1 = 0 ;
23179 int res1 = 0 ;
23180 void *argp2 = 0 ;
23181 int res2 = 0 ;
23182 PyObject *swig_obj[2] ;
23183
23184 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23186 if (!SWIG_IsOK(res1)) {
23187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23188 }
23189 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23190 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23191 if (!SWIG_IsOK(res2)) {
23192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23193 }
23194 arg2 = reinterpret_cast< wxRect * >(argp2);
23195 if (arg1) (arg1)->m_rect = *arg2;
23196
23197 resultobj = SWIG_Py_Void();
23198 return resultobj;
23199 fail:
23200 return NULL;
23201 }
23202
23203
23204 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23205 PyObject *resultobj = 0;
23206 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23207 wxRect *result = 0 ;
23208 void *argp1 = 0 ;
23209 int res1 = 0 ;
23210 PyObject *swig_obj[1] ;
23211
23212 if (!args) SWIG_fail;
23213 swig_obj[0] = args;
23214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23215 if (!SWIG_IsOK(res1)) {
23216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23217 }
23218 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23219 result = (wxRect *)& ((arg1)->m_rect);
23220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23221 return resultobj;
23222 fail:
23223 return NULL;
23224 }
23225
23226
23227 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23228 PyObject *obj;
23229 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23230 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23231 return SWIG_Py_Void();
23232 }
23233
23234 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23235 return SWIG_Python_InitShadowInstance(args);
23236 }
23237
23238 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23239 PyObject *resultobj = 0;
23240 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23241 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23242 int arg2 = (int) 0 ;
23243 wxMoveEvent *result = 0 ;
23244 wxPoint temp1 ;
23245 int val2 ;
23246 int ecode2 = 0 ;
23247 PyObject * obj0 = 0 ;
23248 PyObject * obj1 = 0 ;
23249 char * kwnames[] = {
23250 (char *) "pos",(char *) "winid", NULL
23251 };
23252
23253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23254 if (obj0) {
23255 {
23256 arg1 = &temp1;
23257 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23258 }
23259 }
23260 if (obj1) {
23261 ecode2 = SWIG_AsVal_int(obj1, &val2);
23262 if (!SWIG_IsOK(ecode2)) {
23263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23264 }
23265 arg2 = static_cast< int >(val2);
23266 }
23267 {
23268 PyThreadState* __tstate = wxPyBeginAllowThreads();
23269 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23270 wxPyEndAllowThreads(__tstate);
23271 if (PyErr_Occurred()) SWIG_fail;
23272 }
23273 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23274 return resultobj;
23275 fail:
23276 return NULL;
23277 }
23278
23279
23280 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23281 PyObject *resultobj = 0;
23282 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23283 wxPoint result;
23284 void *argp1 = 0 ;
23285 int res1 = 0 ;
23286 PyObject *swig_obj[1] ;
23287
23288 if (!args) SWIG_fail;
23289 swig_obj[0] = args;
23290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23291 if (!SWIG_IsOK(res1)) {
23292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23293 }
23294 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23295 {
23296 PyThreadState* __tstate = wxPyBeginAllowThreads();
23297 result = ((wxMoveEvent const *)arg1)->GetPosition();
23298 wxPyEndAllowThreads(__tstate);
23299 if (PyErr_Occurred()) SWIG_fail;
23300 }
23301 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23302 return resultobj;
23303 fail:
23304 return NULL;
23305 }
23306
23307
23308 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23309 PyObject *resultobj = 0;
23310 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23311 wxRect result;
23312 void *argp1 = 0 ;
23313 int res1 = 0 ;
23314 PyObject *swig_obj[1] ;
23315
23316 if (!args) SWIG_fail;
23317 swig_obj[0] = args;
23318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23319 if (!SWIG_IsOK(res1)) {
23320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23321 }
23322 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23323 {
23324 PyThreadState* __tstate = wxPyBeginAllowThreads();
23325 result = ((wxMoveEvent const *)arg1)->GetRect();
23326 wxPyEndAllowThreads(__tstate);
23327 if (PyErr_Occurred()) SWIG_fail;
23328 }
23329 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23330 return resultobj;
23331 fail:
23332 return NULL;
23333 }
23334
23335
23336 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23337 PyObject *resultobj = 0;
23338 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23339 wxRect *arg2 = 0 ;
23340 void *argp1 = 0 ;
23341 int res1 = 0 ;
23342 wxRect temp2 ;
23343 PyObject * obj0 = 0 ;
23344 PyObject * obj1 = 0 ;
23345 char * kwnames[] = {
23346 (char *) "self",(char *) "rect", NULL
23347 };
23348
23349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23351 if (!SWIG_IsOK(res1)) {
23352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23353 }
23354 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23355 {
23356 arg2 = &temp2;
23357 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23358 }
23359 {
23360 PyThreadState* __tstate = wxPyBeginAllowThreads();
23361 (arg1)->SetRect((wxRect const &)*arg2);
23362 wxPyEndAllowThreads(__tstate);
23363 if (PyErr_Occurred()) SWIG_fail;
23364 }
23365 resultobj = SWIG_Py_Void();
23366 return resultobj;
23367 fail:
23368 return NULL;
23369 }
23370
23371
23372 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23373 PyObject *resultobj = 0;
23374 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23375 wxPoint *arg2 = 0 ;
23376 void *argp1 = 0 ;
23377 int res1 = 0 ;
23378 wxPoint temp2 ;
23379 PyObject * obj0 = 0 ;
23380 PyObject * obj1 = 0 ;
23381 char * kwnames[] = {
23382 (char *) "self",(char *) "pos", NULL
23383 };
23384
23385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23387 if (!SWIG_IsOK(res1)) {
23388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23389 }
23390 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23391 {
23392 arg2 = &temp2;
23393 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23394 }
23395 {
23396 PyThreadState* __tstate = wxPyBeginAllowThreads();
23397 (arg1)->SetPosition((wxPoint const &)*arg2);
23398 wxPyEndAllowThreads(__tstate);
23399 if (PyErr_Occurred()) SWIG_fail;
23400 }
23401 resultobj = SWIG_Py_Void();
23402 return resultobj;
23403 fail:
23404 return NULL;
23405 }
23406
23407
23408 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23409 PyObject *obj;
23410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23411 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23412 return SWIG_Py_Void();
23413 }
23414
23415 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23416 return SWIG_Python_InitShadowInstance(args);
23417 }
23418
23419 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23420 PyObject *resultobj = 0;
23421 int arg1 = (int) 0 ;
23422 wxPaintEvent *result = 0 ;
23423 int val1 ;
23424 int ecode1 = 0 ;
23425 PyObject * obj0 = 0 ;
23426 char * kwnames[] = {
23427 (char *) "Id", NULL
23428 };
23429
23430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23431 if (obj0) {
23432 ecode1 = SWIG_AsVal_int(obj0, &val1);
23433 if (!SWIG_IsOK(ecode1)) {
23434 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23435 }
23436 arg1 = static_cast< int >(val1);
23437 }
23438 {
23439 PyThreadState* __tstate = wxPyBeginAllowThreads();
23440 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23441 wxPyEndAllowThreads(__tstate);
23442 if (PyErr_Occurred()) SWIG_fail;
23443 }
23444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23445 return resultobj;
23446 fail:
23447 return NULL;
23448 }
23449
23450
23451 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23452 PyObject *obj;
23453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23454 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23455 return SWIG_Py_Void();
23456 }
23457
23458 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23459 return SWIG_Python_InitShadowInstance(args);
23460 }
23461
23462 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23463 PyObject *resultobj = 0;
23464 int arg1 = (int) 0 ;
23465 wxNcPaintEvent *result = 0 ;
23466 int val1 ;
23467 int ecode1 = 0 ;
23468 PyObject * obj0 = 0 ;
23469 char * kwnames[] = {
23470 (char *) "winid", NULL
23471 };
23472
23473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23474 if (obj0) {
23475 ecode1 = SWIG_AsVal_int(obj0, &val1);
23476 if (!SWIG_IsOK(ecode1)) {
23477 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23478 }
23479 arg1 = static_cast< int >(val1);
23480 }
23481 {
23482 PyThreadState* __tstate = wxPyBeginAllowThreads();
23483 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23484 wxPyEndAllowThreads(__tstate);
23485 if (PyErr_Occurred()) SWIG_fail;
23486 }
23487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23488 return resultobj;
23489 fail:
23490 return NULL;
23491 }
23492
23493
23494 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23495 PyObject *obj;
23496 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23497 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23498 return SWIG_Py_Void();
23499 }
23500
23501 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23502 return SWIG_Python_InitShadowInstance(args);
23503 }
23504
23505 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23506 PyObject *resultobj = 0;
23507 int arg1 = (int) 0 ;
23508 wxDC *arg2 = (wxDC *) NULL ;
23509 wxEraseEvent *result = 0 ;
23510 int val1 ;
23511 int ecode1 = 0 ;
23512 void *argp2 = 0 ;
23513 int res2 = 0 ;
23514 PyObject * obj0 = 0 ;
23515 PyObject * obj1 = 0 ;
23516 char * kwnames[] = {
23517 (char *) "Id",(char *) "dc", NULL
23518 };
23519
23520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23521 if (obj0) {
23522 ecode1 = SWIG_AsVal_int(obj0, &val1);
23523 if (!SWIG_IsOK(ecode1)) {
23524 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23525 }
23526 arg1 = static_cast< int >(val1);
23527 }
23528 if (obj1) {
23529 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23530 if (!SWIG_IsOK(res2)) {
23531 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23532 }
23533 arg2 = reinterpret_cast< wxDC * >(argp2);
23534 }
23535 {
23536 PyThreadState* __tstate = wxPyBeginAllowThreads();
23537 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23538 wxPyEndAllowThreads(__tstate);
23539 if (PyErr_Occurred()) SWIG_fail;
23540 }
23541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23542 return resultobj;
23543 fail:
23544 return NULL;
23545 }
23546
23547
23548 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23549 PyObject *resultobj = 0;
23550 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23551 wxDC *result = 0 ;
23552 void *argp1 = 0 ;
23553 int res1 = 0 ;
23554 PyObject *swig_obj[1] ;
23555
23556 if (!args) SWIG_fail;
23557 swig_obj[0] = args;
23558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23559 if (!SWIG_IsOK(res1)) {
23560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23561 }
23562 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23563 {
23564 PyThreadState* __tstate = wxPyBeginAllowThreads();
23565 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23566 wxPyEndAllowThreads(__tstate);
23567 if (PyErr_Occurred()) SWIG_fail;
23568 }
23569 {
23570 resultobj = wxPyMake_wxObject(result, (bool)0);
23571 }
23572 return resultobj;
23573 fail:
23574 return NULL;
23575 }
23576
23577
23578 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23579 PyObject *obj;
23580 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23581 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23582 return SWIG_Py_Void();
23583 }
23584
23585 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23586 return SWIG_Python_InitShadowInstance(args);
23587 }
23588
23589 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23590 PyObject *resultobj = 0;
23591 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23592 int arg2 = (int) 0 ;
23593 wxFocusEvent *result = 0 ;
23594 int val1 ;
23595 int ecode1 = 0 ;
23596 int val2 ;
23597 int ecode2 = 0 ;
23598 PyObject * obj0 = 0 ;
23599 PyObject * obj1 = 0 ;
23600 char * kwnames[] = {
23601 (char *) "type",(char *) "winid", NULL
23602 };
23603
23604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23605 if (obj0) {
23606 ecode1 = SWIG_AsVal_int(obj0, &val1);
23607 if (!SWIG_IsOK(ecode1)) {
23608 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23609 }
23610 arg1 = static_cast< wxEventType >(val1);
23611 }
23612 if (obj1) {
23613 ecode2 = SWIG_AsVal_int(obj1, &val2);
23614 if (!SWIG_IsOK(ecode2)) {
23615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23616 }
23617 arg2 = static_cast< int >(val2);
23618 }
23619 {
23620 PyThreadState* __tstate = wxPyBeginAllowThreads();
23621 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23622 wxPyEndAllowThreads(__tstate);
23623 if (PyErr_Occurred()) SWIG_fail;
23624 }
23625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23626 return resultobj;
23627 fail:
23628 return NULL;
23629 }
23630
23631
23632 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23633 PyObject *resultobj = 0;
23634 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23635 wxWindow *result = 0 ;
23636 void *argp1 = 0 ;
23637 int res1 = 0 ;
23638 PyObject *swig_obj[1] ;
23639
23640 if (!args) SWIG_fail;
23641 swig_obj[0] = args;
23642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23643 if (!SWIG_IsOK(res1)) {
23644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23645 }
23646 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23647 {
23648 PyThreadState* __tstate = wxPyBeginAllowThreads();
23649 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23650 wxPyEndAllowThreads(__tstate);
23651 if (PyErr_Occurred()) SWIG_fail;
23652 }
23653 {
23654 resultobj = wxPyMake_wxObject(result, (bool)0);
23655 }
23656 return resultobj;
23657 fail:
23658 return NULL;
23659 }
23660
23661
23662 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23663 PyObject *resultobj = 0;
23664 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23665 wxWindow *arg2 = (wxWindow *) 0 ;
23666 void *argp1 = 0 ;
23667 int res1 = 0 ;
23668 void *argp2 = 0 ;
23669 int res2 = 0 ;
23670 PyObject * obj0 = 0 ;
23671 PyObject * obj1 = 0 ;
23672 char * kwnames[] = {
23673 (char *) "self",(char *) "win", NULL
23674 };
23675
23676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23678 if (!SWIG_IsOK(res1)) {
23679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23680 }
23681 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23682 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23683 if (!SWIG_IsOK(res2)) {
23684 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23685 }
23686 arg2 = reinterpret_cast< wxWindow * >(argp2);
23687 {
23688 PyThreadState* __tstate = wxPyBeginAllowThreads();
23689 (arg1)->SetWindow(arg2);
23690 wxPyEndAllowThreads(__tstate);
23691 if (PyErr_Occurred()) SWIG_fail;
23692 }
23693 resultobj = SWIG_Py_Void();
23694 return resultobj;
23695 fail:
23696 return NULL;
23697 }
23698
23699
23700 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23701 PyObject *obj;
23702 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23703 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23704 return SWIG_Py_Void();
23705 }
23706
23707 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23708 return SWIG_Python_InitShadowInstance(args);
23709 }
23710
23711 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23712 PyObject *resultobj = 0;
23713 wxWindow *arg1 = (wxWindow *) NULL ;
23714 wxChildFocusEvent *result = 0 ;
23715 void *argp1 = 0 ;
23716 int res1 = 0 ;
23717 PyObject * obj0 = 0 ;
23718 char * kwnames[] = {
23719 (char *) "win", NULL
23720 };
23721
23722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23723 if (obj0) {
23724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23725 if (!SWIG_IsOK(res1)) {
23726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23727 }
23728 arg1 = reinterpret_cast< wxWindow * >(argp1);
23729 }
23730 {
23731 PyThreadState* __tstate = wxPyBeginAllowThreads();
23732 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23733 wxPyEndAllowThreads(__tstate);
23734 if (PyErr_Occurred()) SWIG_fail;
23735 }
23736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23737 return resultobj;
23738 fail:
23739 return NULL;
23740 }
23741
23742
23743 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23744 PyObject *resultobj = 0;
23745 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23746 wxWindow *result = 0 ;
23747 void *argp1 = 0 ;
23748 int res1 = 0 ;
23749 PyObject *swig_obj[1] ;
23750
23751 if (!args) SWIG_fail;
23752 swig_obj[0] = args;
23753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23754 if (!SWIG_IsOK(res1)) {
23755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23756 }
23757 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23758 {
23759 PyThreadState* __tstate = wxPyBeginAllowThreads();
23760 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23761 wxPyEndAllowThreads(__tstate);
23762 if (PyErr_Occurred()) SWIG_fail;
23763 }
23764 {
23765 resultobj = wxPyMake_wxObject(result, (bool)0);
23766 }
23767 return resultobj;
23768 fail:
23769 return NULL;
23770 }
23771
23772
23773 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23774 PyObject *obj;
23775 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23776 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23777 return SWIG_Py_Void();
23778 }
23779
23780 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23781 return SWIG_Python_InitShadowInstance(args);
23782 }
23783
23784 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23785 PyObject *resultobj = 0;
23786 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23787 bool arg2 = (bool) true ;
23788 int arg3 = (int) 0 ;
23789 wxActivateEvent *result = 0 ;
23790 int val1 ;
23791 int ecode1 = 0 ;
23792 bool val2 ;
23793 int ecode2 = 0 ;
23794 int val3 ;
23795 int ecode3 = 0 ;
23796 PyObject * obj0 = 0 ;
23797 PyObject * obj1 = 0 ;
23798 PyObject * obj2 = 0 ;
23799 char * kwnames[] = {
23800 (char *) "type",(char *) "active",(char *) "Id", NULL
23801 };
23802
23803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23804 if (obj0) {
23805 ecode1 = SWIG_AsVal_int(obj0, &val1);
23806 if (!SWIG_IsOK(ecode1)) {
23807 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23808 }
23809 arg1 = static_cast< wxEventType >(val1);
23810 }
23811 if (obj1) {
23812 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23813 if (!SWIG_IsOK(ecode2)) {
23814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23815 }
23816 arg2 = static_cast< bool >(val2);
23817 }
23818 if (obj2) {
23819 ecode3 = SWIG_AsVal_int(obj2, &val3);
23820 if (!SWIG_IsOK(ecode3)) {
23821 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23822 }
23823 arg3 = static_cast< int >(val3);
23824 }
23825 {
23826 PyThreadState* __tstate = wxPyBeginAllowThreads();
23827 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23828 wxPyEndAllowThreads(__tstate);
23829 if (PyErr_Occurred()) SWIG_fail;
23830 }
23831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23832 return resultobj;
23833 fail:
23834 return NULL;
23835 }
23836
23837
23838 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23839 PyObject *resultobj = 0;
23840 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23841 bool result;
23842 void *argp1 = 0 ;
23843 int res1 = 0 ;
23844 PyObject *swig_obj[1] ;
23845
23846 if (!args) SWIG_fail;
23847 swig_obj[0] = args;
23848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23849 if (!SWIG_IsOK(res1)) {
23850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23851 }
23852 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23853 {
23854 PyThreadState* __tstate = wxPyBeginAllowThreads();
23855 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23856 wxPyEndAllowThreads(__tstate);
23857 if (PyErr_Occurred()) SWIG_fail;
23858 }
23859 {
23860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23861 }
23862 return resultobj;
23863 fail:
23864 return NULL;
23865 }
23866
23867
23868 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23869 PyObject *obj;
23870 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23871 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23872 return SWIG_Py_Void();
23873 }
23874
23875 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23876 return SWIG_Python_InitShadowInstance(args);
23877 }
23878
23879 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23880 PyObject *resultobj = 0;
23881 int arg1 = (int) 0 ;
23882 wxInitDialogEvent *result = 0 ;
23883 int val1 ;
23884 int ecode1 = 0 ;
23885 PyObject * obj0 = 0 ;
23886 char * kwnames[] = {
23887 (char *) "Id", NULL
23888 };
23889
23890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23891 if (obj0) {
23892 ecode1 = SWIG_AsVal_int(obj0, &val1);
23893 if (!SWIG_IsOK(ecode1)) {
23894 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23895 }
23896 arg1 = static_cast< int >(val1);
23897 }
23898 {
23899 PyThreadState* __tstate = wxPyBeginAllowThreads();
23900 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23901 wxPyEndAllowThreads(__tstate);
23902 if (PyErr_Occurred()) SWIG_fail;
23903 }
23904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23905 return resultobj;
23906 fail:
23907 return NULL;
23908 }
23909
23910
23911 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23912 PyObject *obj;
23913 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23914 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23915 return SWIG_Py_Void();
23916 }
23917
23918 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23919 return SWIG_Python_InitShadowInstance(args);
23920 }
23921
23922 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23923 PyObject *resultobj = 0;
23924 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23925 int arg2 = (int) 0 ;
23926 wxMenu *arg3 = (wxMenu *) NULL ;
23927 wxMenuEvent *result = 0 ;
23928 int val1 ;
23929 int ecode1 = 0 ;
23930 int val2 ;
23931 int ecode2 = 0 ;
23932 void *argp3 = 0 ;
23933 int res3 = 0 ;
23934 PyObject * obj0 = 0 ;
23935 PyObject * obj1 = 0 ;
23936 PyObject * obj2 = 0 ;
23937 char * kwnames[] = {
23938 (char *) "type",(char *) "winid",(char *) "menu", NULL
23939 };
23940
23941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23942 if (obj0) {
23943 ecode1 = SWIG_AsVal_int(obj0, &val1);
23944 if (!SWIG_IsOK(ecode1)) {
23945 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23946 }
23947 arg1 = static_cast< wxEventType >(val1);
23948 }
23949 if (obj1) {
23950 ecode2 = SWIG_AsVal_int(obj1, &val2);
23951 if (!SWIG_IsOK(ecode2)) {
23952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23953 }
23954 arg2 = static_cast< int >(val2);
23955 }
23956 if (obj2) {
23957 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23958 if (!SWIG_IsOK(res3)) {
23959 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23960 }
23961 arg3 = reinterpret_cast< wxMenu * >(argp3);
23962 }
23963 {
23964 PyThreadState* __tstate = wxPyBeginAllowThreads();
23965 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23966 wxPyEndAllowThreads(__tstate);
23967 if (PyErr_Occurred()) SWIG_fail;
23968 }
23969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23970 return resultobj;
23971 fail:
23972 return NULL;
23973 }
23974
23975
23976 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23977 PyObject *resultobj = 0;
23978 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23979 int result;
23980 void *argp1 = 0 ;
23981 int res1 = 0 ;
23982 PyObject *swig_obj[1] ;
23983
23984 if (!args) SWIG_fail;
23985 swig_obj[0] = args;
23986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23987 if (!SWIG_IsOK(res1)) {
23988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23989 }
23990 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23991 {
23992 PyThreadState* __tstate = wxPyBeginAllowThreads();
23993 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23994 wxPyEndAllowThreads(__tstate);
23995 if (PyErr_Occurred()) SWIG_fail;
23996 }
23997 resultobj = SWIG_From_int(static_cast< int >(result));
23998 return resultobj;
23999 fail:
24000 return NULL;
24001 }
24002
24003
24004 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24005 PyObject *resultobj = 0;
24006 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24007 bool result;
24008 void *argp1 = 0 ;
24009 int res1 = 0 ;
24010 PyObject *swig_obj[1] ;
24011
24012 if (!args) SWIG_fail;
24013 swig_obj[0] = args;
24014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24015 if (!SWIG_IsOK(res1)) {
24016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24017 }
24018 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24019 {
24020 PyThreadState* __tstate = wxPyBeginAllowThreads();
24021 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24022 wxPyEndAllowThreads(__tstate);
24023 if (PyErr_Occurred()) SWIG_fail;
24024 }
24025 {
24026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24027 }
24028 return resultobj;
24029 fail:
24030 return NULL;
24031 }
24032
24033
24034 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24035 PyObject *resultobj = 0;
24036 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24037 wxMenu *result = 0 ;
24038 void *argp1 = 0 ;
24039 int res1 = 0 ;
24040 PyObject *swig_obj[1] ;
24041
24042 if (!args) SWIG_fail;
24043 swig_obj[0] = args;
24044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24045 if (!SWIG_IsOK(res1)) {
24046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24047 }
24048 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24049 {
24050 PyThreadState* __tstate = wxPyBeginAllowThreads();
24051 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24052 wxPyEndAllowThreads(__tstate);
24053 if (PyErr_Occurred()) SWIG_fail;
24054 }
24055 {
24056 resultobj = wxPyMake_wxObject(result, (bool)0);
24057 }
24058 return resultobj;
24059 fail:
24060 return NULL;
24061 }
24062
24063
24064 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24065 PyObject *obj;
24066 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24067 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24068 return SWIG_Py_Void();
24069 }
24070
24071 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24072 return SWIG_Python_InitShadowInstance(args);
24073 }
24074
24075 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24076 PyObject *resultobj = 0;
24077 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24078 int arg2 = (int) 0 ;
24079 wxCloseEvent *result = 0 ;
24080 int val1 ;
24081 int ecode1 = 0 ;
24082 int val2 ;
24083 int ecode2 = 0 ;
24084 PyObject * obj0 = 0 ;
24085 PyObject * obj1 = 0 ;
24086 char * kwnames[] = {
24087 (char *) "type",(char *) "winid", NULL
24088 };
24089
24090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24091 if (obj0) {
24092 ecode1 = SWIG_AsVal_int(obj0, &val1);
24093 if (!SWIG_IsOK(ecode1)) {
24094 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24095 }
24096 arg1 = static_cast< wxEventType >(val1);
24097 }
24098 if (obj1) {
24099 ecode2 = SWIG_AsVal_int(obj1, &val2);
24100 if (!SWIG_IsOK(ecode2)) {
24101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24102 }
24103 arg2 = static_cast< int >(val2);
24104 }
24105 {
24106 PyThreadState* __tstate = wxPyBeginAllowThreads();
24107 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24108 wxPyEndAllowThreads(__tstate);
24109 if (PyErr_Occurred()) SWIG_fail;
24110 }
24111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24112 return resultobj;
24113 fail:
24114 return NULL;
24115 }
24116
24117
24118 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24119 PyObject *resultobj = 0;
24120 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24121 bool arg2 ;
24122 void *argp1 = 0 ;
24123 int res1 = 0 ;
24124 bool val2 ;
24125 int ecode2 = 0 ;
24126 PyObject * obj0 = 0 ;
24127 PyObject * obj1 = 0 ;
24128 char * kwnames[] = {
24129 (char *) "self",(char *) "logOff", NULL
24130 };
24131
24132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24134 if (!SWIG_IsOK(res1)) {
24135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24136 }
24137 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24138 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24139 if (!SWIG_IsOK(ecode2)) {
24140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24141 }
24142 arg2 = static_cast< bool >(val2);
24143 {
24144 PyThreadState* __tstate = wxPyBeginAllowThreads();
24145 (arg1)->SetLoggingOff(arg2);
24146 wxPyEndAllowThreads(__tstate);
24147 if (PyErr_Occurred()) SWIG_fail;
24148 }
24149 resultobj = SWIG_Py_Void();
24150 return resultobj;
24151 fail:
24152 return NULL;
24153 }
24154
24155
24156 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24157 PyObject *resultobj = 0;
24158 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24159 bool result;
24160 void *argp1 = 0 ;
24161 int res1 = 0 ;
24162 PyObject *swig_obj[1] ;
24163
24164 if (!args) SWIG_fail;
24165 swig_obj[0] = args;
24166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24167 if (!SWIG_IsOK(res1)) {
24168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24169 }
24170 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24171 {
24172 PyThreadState* __tstate = wxPyBeginAllowThreads();
24173 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24174 wxPyEndAllowThreads(__tstate);
24175 if (PyErr_Occurred()) SWIG_fail;
24176 }
24177 {
24178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24179 }
24180 return resultobj;
24181 fail:
24182 return NULL;
24183 }
24184
24185
24186 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24187 PyObject *resultobj = 0;
24188 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24189 bool arg2 = (bool) true ;
24190 void *argp1 = 0 ;
24191 int res1 = 0 ;
24192 bool val2 ;
24193 int ecode2 = 0 ;
24194 PyObject * obj0 = 0 ;
24195 PyObject * obj1 = 0 ;
24196 char * kwnames[] = {
24197 (char *) "self",(char *) "veto", NULL
24198 };
24199
24200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24202 if (!SWIG_IsOK(res1)) {
24203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24204 }
24205 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24206 if (obj1) {
24207 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24208 if (!SWIG_IsOK(ecode2)) {
24209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24210 }
24211 arg2 = static_cast< bool >(val2);
24212 }
24213 {
24214 PyThreadState* __tstate = wxPyBeginAllowThreads();
24215 (arg1)->Veto(arg2);
24216 wxPyEndAllowThreads(__tstate);
24217 if (PyErr_Occurred()) SWIG_fail;
24218 }
24219 resultobj = SWIG_Py_Void();
24220 return resultobj;
24221 fail:
24222 return NULL;
24223 }
24224
24225
24226 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24227 PyObject *resultobj = 0;
24228 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24229 bool result;
24230 void *argp1 = 0 ;
24231 int res1 = 0 ;
24232 PyObject *swig_obj[1] ;
24233
24234 if (!args) SWIG_fail;
24235 swig_obj[0] = args;
24236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24237 if (!SWIG_IsOK(res1)) {
24238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24239 }
24240 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24241 {
24242 PyThreadState* __tstate = wxPyBeginAllowThreads();
24243 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24244 wxPyEndAllowThreads(__tstate);
24245 if (PyErr_Occurred()) SWIG_fail;
24246 }
24247 {
24248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24249 }
24250 return resultobj;
24251 fail:
24252 return NULL;
24253 }
24254
24255
24256 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24257 PyObject *resultobj = 0;
24258 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24259 bool arg2 ;
24260 void *argp1 = 0 ;
24261 int res1 = 0 ;
24262 bool val2 ;
24263 int ecode2 = 0 ;
24264 PyObject * obj0 = 0 ;
24265 PyObject * obj1 = 0 ;
24266 char * kwnames[] = {
24267 (char *) "self",(char *) "canVeto", NULL
24268 };
24269
24270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24272 if (!SWIG_IsOK(res1)) {
24273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24274 }
24275 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24276 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24277 if (!SWIG_IsOK(ecode2)) {
24278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24279 }
24280 arg2 = static_cast< bool >(val2);
24281 {
24282 PyThreadState* __tstate = wxPyBeginAllowThreads();
24283 (arg1)->SetCanVeto(arg2);
24284 wxPyEndAllowThreads(__tstate);
24285 if (PyErr_Occurred()) SWIG_fail;
24286 }
24287 resultobj = SWIG_Py_Void();
24288 return resultobj;
24289 fail:
24290 return NULL;
24291 }
24292
24293
24294 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24295 PyObject *resultobj = 0;
24296 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24297 bool result;
24298 void *argp1 = 0 ;
24299 int res1 = 0 ;
24300 PyObject *swig_obj[1] ;
24301
24302 if (!args) SWIG_fail;
24303 swig_obj[0] = args;
24304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24305 if (!SWIG_IsOK(res1)) {
24306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24307 }
24308 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24309 {
24310 PyThreadState* __tstate = wxPyBeginAllowThreads();
24311 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24312 wxPyEndAllowThreads(__tstate);
24313 if (PyErr_Occurred()) SWIG_fail;
24314 }
24315 {
24316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24317 }
24318 return resultobj;
24319 fail:
24320 return NULL;
24321 }
24322
24323
24324 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24325 PyObject *obj;
24326 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24327 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24328 return SWIG_Py_Void();
24329 }
24330
24331 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24332 return SWIG_Python_InitShadowInstance(args);
24333 }
24334
24335 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24336 PyObject *resultobj = 0;
24337 int arg1 = (int) 0 ;
24338 bool arg2 = (bool) false ;
24339 wxShowEvent *result = 0 ;
24340 int val1 ;
24341 int ecode1 = 0 ;
24342 bool val2 ;
24343 int ecode2 = 0 ;
24344 PyObject * obj0 = 0 ;
24345 PyObject * obj1 = 0 ;
24346 char * kwnames[] = {
24347 (char *) "winid",(char *) "show", NULL
24348 };
24349
24350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24351 if (obj0) {
24352 ecode1 = SWIG_AsVal_int(obj0, &val1);
24353 if (!SWIG_IsOK(ecode1)) {
24354 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24355 }
24356 arg1 = static_cast< int >(val1);
24357 }
24358 if (obj1) {
24359 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24360 if (!SWIG_IsOK(ecode2)) {
24361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24362 }
24363 arg2 = static_cast< bool >(val2);
24364 }
24365 {
24366 PyThreadState* __tstate = wxPyBeginAllowThreads();
24367 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24368 wxPyEndAllowThreads(__tstate);
24369 if (PyErr_Occurred()) SWIG_fail;
24370 }
24371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24372 return resultobj;
24373 fail:
24374 return NULL;
24375 }
24376
24377
24378 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24379 PyObject *resultobj = 0;
24380 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24381 bool arg2 ;
24382 void *argp1 = 0 ;
24383 int res1 = 0 ;
24384 bool val2 ;
24385 int ecode2 = 0 ;
24386 PyObject * obj0 = 0 ;
24387 PyObject * obj1 = 0 ;
24388 char * kwnames[] = {
24389 (char *) "self",(char *) "show", NULL
24390 };
24391
24392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24394 if (!SWIG_IsOK(res1)) {
24395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24396 }
24397 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24398 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24399 if (!SWIG_IsOK(ecode2)) {
24400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24401 }
24402 arg2 = static_cast< bool >(val2);
24403 {
24404 PyThreadState* __tstate = wxPyBeginAllowThreads();
24405 (arg1)->SetShow(arg2);
24406 wxPyEndAllowThreads(__tstate);
24407 if (PyErr_Occurred()) SWIG_fail;
24408 }
24409 resultobj = SWIG_Py_Void();
24410 return resultobj;
24411 fail:
24412 return NULL;
24413 }
24414
24415
24416 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24417 PyObject *resultobj = 0;
24418 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24419 bool result;
24420 void *argp1 = 0 ;
24421 int res1 = 0 ;
24422 PyObject *swig_obj[1] ;
24423
24424 if (!args) SWIG_fail;
24425 swig_obj[0] = args;
24426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24427 if (!SWIG_IsOK(res1)) {
24428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24429 }
24430 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24431 {
24432 PyThreadState* __tstate = wxPyBeginAllowThreads();
24433 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24434 wxPyEndAllowThreads(__tstate);
24435 if (PyErr_Occurred()) SWIG_fail;
24436 }
24437 {
24438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24439 }
24440 return resultobj;
24441 fail:
24442 return NULL;
24443 }
24444
24445
24446 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24447 PyObject *obj;
24448 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24449 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24450 return SWIG_Py_Void();
24451 }
24452
24453 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24454 return SWIG_Python_InitShadowInstance(args);
24455 }
24456
24457 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24458 PyObject *resultobj = 0;
24459 int arg1 = (int) 0 ;
24460 bool arg2 = (bool) true ;
24461 wxIconizeEvent *result = 0 ;
24462 int val1 ;
24463 int ecode1 = 0 ;
24464 bool val2 ;
24465 int ecode2 = 0 ;
24466 PyObject * obj0 = 0 ;
24467 PyObject * obj1 = 0 ;
24468 char * kwnames[] = {
24469 (char *) "id",(char *) "iconized", NULL
24470 };
24471
24472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24473 if (obj0) {
24474 ecode1 = SWIG_AsVal_int(obj0, &val1);
24475 if (!SWIG_IsOK(ecode1)) {
24476 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24477 }
24478 arg1 = static_cast< int >(val1);
24479 }
24480 if (obj1) {
24481 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24482 if (!SWIG_IsOK(ecode2)) {
24483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24484 }
24485 arg2 = static_cast< bool >(val2);
24486 }
24487 {
24488 PyThreadState* __tstate = wxPyBeginAllowThreads();
24489 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24490 wxPyEndAllowThreads(__tstate);
24491 if (PyErr_Occurred()) SWIG_fail;
24492 }
24493 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24494 return resultobj;
24495 fail:
24496 return NULL;
24497 }
24498
24499
24500 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24501 PyObject *resultobj = 0;
24502 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24503 bool result;
24504 void *argp1 = 0 ;
24505 int res1 = 0 ;
24506 PyObject *swig_obj[1] ;
24507
24508 if (!args) SWIG_fail;
24509 swig_obj[0] = args;
24510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24511 if (!SWIG_IsOK(res1)) {
24512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24513 }
24514 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24515 {
24516 PyThreadState* __tstate = wxPyBeginAllowThreads();
24517 result = (bool)(arg1)->Iconized();
24518 wxPyEndAllowThreads(__tstate);
24519 if (PyErr_Occurred()) SWIG_fail;
24520 }
24521 {
24522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24523 }
24524 return resultobj;
24525 fail:
24526 return NULL;
24527 }
24528
24529
24530 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24531 PyObject *obj;
24532 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24533 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24534 return SWIG_Py_Void();
24535 }
24536
24537 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24538 return SWIG_Python_InitShadowInstance(args);
24539 }
24540
24541 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24542 PyObject *resultobj = 0;
24543 int arg1 = (int) 0 ;
24544 wxMaximizeEvent *result = 0 ;
24545 int val1 ;
24546 int ecode1 = 0 ;
24547 PyObject * obj0 = 0 ;
24548 char * kwnames[] = {
24549 (char *) "id", NULL
24550 };
24551
24552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24553 if (obj0) {
24554 ecode1 = SWIG_AsVal_int(obj0, &val1);
24555 if (!SWIG_IsOK(ecode1)) {
24556 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24557 }
24558 arg1 = static_cast< int >(val1);
24559 }
24560 {
24561 PyThreadState* __tstate = wxPyBeginAllowThreads();
24562 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24563 wxPyEndAllowThreads(__tstate);
24564 if (PyErr_Occurred()) SWIG_fail;
24565 }
24566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24567 return resultobj;
24568 fail:
24569 return NULL;
24570 }
24571
24572
24573 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24574 PyObject *obj;
24575 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24576 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24577 return SWIG_Py_Void();
24578 }
24579
24580 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24581 return SWIG_Python_InitShadowInstance(args);
24582 }
24583
24584 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24585 PyObject *resultobj = 0;
24586 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24587 wxPoint result;
24588 void *argp1 = 0 ;
24589 int res1 = 0 ;
24590 PyObject *swig_obj[1] ;
24591
24592 if (!args) SWIG_fail;
24593 swig_obj[0] = args;
24594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24595 if (!SWIG_IsOK(res1)) {
24596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24597 }
24598 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24599 {
24600 PyThreadState* __tstate = wxPyBeginAllowThreads();
24601 result = (arg1)->GetPosition();
24602 wxPyEndAllowThreads(__tstate);
24603 if (PyErr_Occurred()) SWIG_fail;
24604 }
24605 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24606 return resultobj;
24607 fail:
24608 return NULL;
24609 }
24610
24611
24612 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24613 PyObject *resultobj = 0;
24614 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24615 int result;
24616 void *argp1 = 0 ;
24617 int res1 = 0 ;
24618 PyObject *swig_obj[1] ;
24619
24620 if (!args) SWIG_fail;
24621 swig_obj[0] = args;
24622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24623 if (!SWIG_IsOK(res1)) {
24624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24625 }
24626 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24627 {
24628 PyThreadState* __tstate = wxPyBeginAllowThreads();
24629 result = (int)(arg1)->GetNumberOfFiles();
24630 wxPyEndAllowThreads(__tstate);
24631 if (PyErr_Occurred()) SWIG_fail;
24632 }
24633 resultobj = SWIG_From_int(static_cast< int >(result));
24634 return resultobj;
24635 fail:
24636 return NULL;
24637 }
24638
24639
24640 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24641 PyObject *resultobj = 0;
24642 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24643 PyObject *result = 0 ;
24644 void *argp1 = 0 ;
24645 int res1 = 0 ;
24646 PyObject *swig_obj[1] ;
24647
24648 if (!args) SWIG_fail;
24649 swig_obj[0] = args;
24650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24651 if (!SWIG_IsOK(res1)) {
24652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24653 }
24654 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24655 {
24656 PyThreadState* __tstate = wxPyBeginAllowThreads();
24657 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24658 wxPyEndAllowThreads(__tstate);
24659 if (PyErr_Occurred()) SWIG_fail;
24660 }
24661 resultobj = result;
24662 return resultobj;
24663 fail:
24664 return NULL;
24665 }
24666
24667
24668 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24669 PyObject *obj;
24670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24671 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24672 return SWIG_Py_Void();
24673 }
24674
24675 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24676 PyObject *resultobj = 0;
24677 int arg1 = (int) 0 ;
24678 wxUpdateUIEvent *result = 0 ;
24679 int val1 ;
24680 int ecode1 = 0 ;
24681 PyObject * obj0 = 0 ;
24682 char * kwnames[] = {
24683 (char *) "commandId", NULL
24684 };
24685
24686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24687 if (obj0) {
24688 ecode1 = SWIG_AsVal_int(obj0, &val1);
24689 if (!SWIG_IsOK(ecode1)) {
24690 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24691 }
24692 arg1 = static_cast< int >(val1);
24693 }
24694 {
24695 PyThreadState* __tstate = wxPyBeginAllowThreads();
24696 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24697 wxPyEndAllowThreads(__tstate);
24698 if (PyErr_Occurred()) SWIG_fail;
24699 }
24700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24701 return resultobj;
24702 fail:
24703 return NULL;
24704 }
24705
24706
24707 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24708 PyObject *resultobj = 0;
24709 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24710 bool result;
24711 void *argp1 = 0 ;
24712 int res1 = 0 ;
24713 PyObject *swig_obj[1] ;
24714
24715 if (!args) SWIG_fail;
24716 swig_obj[0] = args;
24717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24718 if (!SWIG_IsOK(res1)) {
24719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24720 }
24721 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24722 {
24723 PyThreadState* __tstate = wxPyBeginAllowThreads();
24724 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24725 wxPyEndAllowThreads(__tstate);
24726 if (PyErr_Occurred()) SWIG_fail;
24727 }
24728 {
24729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24730 }
24731 return resultobj;
24732 fail:
24733 return NULL;
24734 }
24735
24736
24737 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24738 PyObject *resultobj = 0;
24739 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24740 bool result;
24741 void *argp1 = 0 ;
24742 int res1 = 0 ;
24743 PyObject *swig_obj[1] ;
24744
24745 if (!args) SWIG_fail;
24746 swig_obj[0] = args;
24747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24748 if (!SWIG_IsOK(res1)) {
24749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24750 }
24751 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24752 {
24753 PyThreadState* __tstate = wxPyBeginAllowThreads();
24754 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24755 wxPyEndAllowThreads(__tstate);
24756 if (PyErr_Occurred()) SWIG_fail;
24757 }
24758 {
24759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24760 }
24761 return resultobj;
24762 fail:
24763 return NULL;
24764 }
24765
24766
24767 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24768 PyObject *resultobj = 0;
24769 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24770 bool result;
24771 void *argp1 = 0 ;
24772 int res1 = 0 ;
24773 PyObject *swig_obj[1] ;
24774
24775 if (!args) SWIG_fail;
24776 swig_obj[0] = args;
24777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24778 if (!SWIG_IsOK(res1)) {
24779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24780 }
24781 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24782 {
24783 PyThreadState* __tstate = wxPyBeginAllowThreads();
24784 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24785 wxPyEndAllowThreads(__tstate);
24786 if (PyErr_Occurred()) SWIG_fail;
24787 }
24788 {
24789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24790 }
24791 return resultobj;
24792 fail:
24793 return NULL;
24794 }
24795
24796
24797 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24798 PyObject *resultobj = 0;
24799 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24800 wxString result;
24801 void *argp1 = 0 ;
24802 int res1 = 0 ;
24803 PyObject *swig_obj[1] ;
24804
24805 if (!args) SWIG_fail;
24806 swig_obj[0] = args;
24807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24808 if (!SWIG_IsOK(res1)) {
24809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24810 }
24811 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24812 {
24813 PyThreadState* __tstate = wxPyBeginAllowThreads();
24814 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24815 wxPyEndAllowThreads(__tstate);
24816 if (PyErr_Occurred()) SWIG_fail;
24817 }
24818 {
24819 #if wxUSE_UNICODE
24820 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24821 #else
24822 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24823 #endif
24824 }
24825 return resultobj;
24826 fail:
24827 return NULL;
24828 }
24829
24830
24831 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24832 PyObject *resultobj = 0;
24833 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24834 bool result;
24835 void *argp1 = 0 ;
24836 int res1 = 0 ;
24837 PyObject *swig_obj[1] ;
24838
24839 if (!args) SWIG_fail;
24840 swig_obj[0] = args;
24841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24842 if (!SWIG_IsOK(res1)) {
24843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24844 }
24845 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24846 {
24847 PyThreadState* __tstate = wxPyBeginAllowThreads();
24848 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24849 wxPyEndAllowThreads(__tstate);
24850 if (PyErr_Occurred()) SWIG_fail;
24851 }
24852 {
24853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24854 }
24855 return resultobj;
24856 fail:
24857 return NULL;
24858 }
24859
24860
24861 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24862 PyObject *resultobj = 0;
24863 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24864 bool result;
24865 void *argp1 = 0 ;
24866 int res1 = 0 ;
24867 PyObject *swig_obj[1] ;
24868
24869 if (!args) SWIG_fail;
24870 swig_obj[0] = args;
24871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24872 if (!SWIG_IsOK(res1)) {
24873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24874 }
24875 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24876 {
24877 PyThreadState* __tstate = wxPyBeginAllowThreads();
24878 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24879 wxPyEndAllowThreads(__tstate);
24880 if (PyErr_Occurred()) SWIG_fail;
24881 }
24882 {
24883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24884 }
24885 return resultobj;
24886 fail:
24887 return NULL;
24888 }
24889
24890
24891 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24892 PyObject *resultobj = 0;
24893 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24894 bool result;
24895 void *argp1 = 0 ;
24896 int res1 = 0 ;
24897 PyObject *swig_obj[1] ;
24898
24899 if (!args) SWIG_fail;
24900 swig_obj[0] = args;
24901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24902 if (!SWIG_IsOK(res1)) {
24903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24904 }
24905 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24906 {
24907 PyThreadState* __tstate = wxPyBeginAllowThreads();
24908 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24909 wxPyEndAllowThreads(__tstate);
24910 if (PyErr_Occurred()) SWIG_fail;
24911 }
24912 {
24913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24914 }
24915 return resultobj;
24916 fail:
24917 return NULL;
24918 }
24919
24920
24921 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24922 PyObject *resultobj = 0;
24923 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24924 bool result;
24925 void *argp1 = 0 ;
24926 int res1 = 0 ;
24927 PyObject *swig_obj[1] ;
24928
24929 if (!args) SWIG_fail;
24930 swig_obj[0] = args;
24931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24932 if (!SWIG_IsOK(res1)) {
24933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24934 }
24935 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24936 {
24937 PyThreadState* __tstate = wxPyBeginAllowThreads();
24938 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24939 wxPyEndAllowThreads(__tstate);
24940 if (PyErr_Occurred()) SWIG_fail;
24941 }
24942 {
24943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24944 }
24945 return resultobj;
24946 fail:
24947 return NULL;
24948 }
24949
24950
24951 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24952 PyObject *resultobj = 0;
24953 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24954 bool arg2 ;
24955 void *argp1 = 0 ;
24956 int res1 = 0 ;
24957 bool val2 ;
24958 int ecode2 = 0 ;
24959 PyObject * obj0 = 0 ;
24960 PyObject * obj1 = 0 ;
24961 char * kwnames[] = {
24962 (char *) "self",(char *) "check", NULL
24963 };
24964
24965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24967 if (!SWIG_IsOK(res1)) {
24968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24969 }
24970 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24971 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24972 if (!SWIG_IsOK(ecode2)) {
24973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24974 }
24975 arg2 = static_cast< bool >(val2);
24976 {
24977 PyThreadState* __tstate = wxPyBeginAllowThreads();
24978 (arg1)->Check(arg2);
24979 wxPyEndAllowThreads(__tstate);
24980 if (PyErr_Occurred()) SWIG_fail;
24981 }
24982 resultobj = SWIG_Py_Void();
24983 return resultobj;
24984 fail:
24985 return NULL;
24986 }
24987
24988
24989 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24990 PyObject *resultobj = 0;
24991 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24992 bool arg2 ;
24993 void *argp1 = 0 ;
24994 int res1 = 0 ;
24995 bool val2 ;
24996 int ecode2 = 0 ;
24997 PyObject * obj0 = 0 ;
24998 PyObject * obj1 = 0 ;
24999 char * kwnames[] = {
25000 (char *) "self",(char *) "enable", NULL
25001 };
25002
25003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25005 if (!SWIG_IsOK(res1)) {
25006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25007 }
25008 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25009 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25010 if (!SWIG_IsOK(ecode2)) {
25011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25012 }
25013 arg2 = static_cast< bool >(val2);
25014 {
25015 PyThreadState* __tstate = wxPyBeginAllowThreads();
25016 (arg1)->Enable(arg2);
25017 wxPyEndAllowThreads(__tstate);
25018 if (PyErr_Occurred()) SWIG_fail;
25019 }
25020 resultobj = SWIG_Py_Void();
25021 return resultobj;
25022 fail:
25023 return NULL;
25024 }
25025
25026
25027 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25028 PyObject *resultobj = 0;
25029 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25030 bool arg2 ;
25031 void *argp1 = 0 ;
25032 int res1 = 0 ;
25033 bool val2 ;
25034 int ecode2 = 0 ;
25035 PyObject * obj0 = 0 ;
25036 PyObject * obj1 = 0 ;
25037 char * kwnames[] = {
25038 (char *) "self",(char *) "show", NULL
25039 };
25040
25041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25043 if (!SWIG_IsOK(res1)) {
25044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25045 }
25046 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25047 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25048 if (!SWIG_IsOK(ecode2)) {
25049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25050 }
25051 arg2 = static_cast< bool >(val2);
25052 {
25053 PyThreadState* __tstate = wxPyBeginAllowThreads();
25054 (arg1)->Show(arg2);
25055 wxPyEndAllowThreads(__tstate);
25056 if (PyErr_Occurred()) SWIG_fail;
25057 }
25058 resultobj = SWIG_Py_Void();
25059 return resultobj;
25060 fail:
25061 return NULL;
25062 }
25063
25064
25065 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25066 PyObject *resultobj = 0;
25067 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25068 wxString *arg2 = 0 ;
25069 void *argp1 = 0 ;
25070 int res1 = 0 ;
25071 bool temp2 = false ;
25072 PyObject * obj0 = 0 ;
25073 PyObject * obj1 = 0 ;
25074 char * kwnames[] = {
25075 (char *) "self",(char *) "text", NULL
25076 };
25077
25078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25080 if (!SWIG_IsOK(res1)) {
25081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25082 }
25083 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25084 {
25085 arg2 = wxString_in_helper(obj1);
25086 if (arg2 == NULL) SWIG_fail;
25087 temp2 = true;
25088 }
25089 {
25090 PyThreadState* __tstate = wxPyBeginAllowThreads();
25091 (arg1)->SetText((wxString const &)*arg2);
25092 wxPyEndAllowThreads(__tstate);
25093 if (PyErr_Occurred()) SWIG_fail;
25094 }
25095 resultobj = SWIG_Py_Void();
25096 {
25097 if (temp2)
25098 delete arg2;
25099 }
25100 return resultobj;
25101 fail:
25102 {
25103 if (temp2)
25104 delete arg2;
25105 }
25106 return NULL;
25107 }
25108
25109
25110 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25111 PyObject *resultobj = 0;
25112 long arg1 ;
25113 long val1 ;
25114 int ecode1 = 0 ;
25115 PyObject * obj0 = 0 ;
25116 char * kwnames[] = {
25117 (char *) "updateInterval", NULL
25118 };
25119
25120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25121 ecode1 = SWIG_AsVal_long(obj0, &val1);
25122 if (!SWIG_IsOK(ecode1)) {
25123 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25124 }
25125 arg1 = static_cast< long >(val1);
25126 {
25127 PyThreadState* __tstate = wxPyBeginAllowThreads();
25128 wxUpdateUIEvent::SetUpdateInterval(arg1);
25129 wxPyEndAllowThreads(__tstate);
25130 if (PyErr_Occurred()) SWIG_fail;
25131 }
25132 resultobj = SWIG_Py_Void();
25133 return resultobj;
25134 fail:
25135 return NULL;
25136 }
25137
25138
25139 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25140 PyObject *resultobj = 0;
25141 long result;
25142
25143 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25144 {
25145 PyThreadState* __tstate = wxPyBeginAllowThreads();
25146 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25147 wxPyEndAllowThreads(__tstate);
25148 if (PyErr_Occurred()) SWIG_fail;
25149 }
25150 resultobj = SWIG_From_long(static_cast< long >(result));
25151 return resultobj;
25152 fail:
25153 return NULL;
25154 }
25155
25156
25157 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25158 PyObject *resultobj = 0;
25159 wxWindow *arg1 = (wxWindow *) 0 ;
25160 bool result;
25161 void *argp1 = 0 ;
25162 int res1 = 0 ;
25163 PyObject * obj0 = 0 ;
25164 char * kwnames[] = {
25165 (char *) "win", NULL
25166 };
25167
25168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25170 if (!SWIG_IsOK(res1)) {
25171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25172 }
25173 arg1 = reinterpret_cast< wxWindow * >(argp1);
25174 {
25175 PyThreadState* __tstate = wxPyBeginAllowThreads();
25176 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25177 wxPyEndAllowThreads(__tstate);
25178 if (PyErr_Occurred()) SWIG_fail;
25179 }
25180 {
25181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25182 }
25183 return resultobj;
25184 fail:
25185 return NULL;
25186 }
25187
25188
25189 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25190 PyObject *resultobj = 0;
25191
25192 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25193 {
25194 PyThreadState* __tstate = wxPyBeginAllowThreads();
25195 wxUpdateUIEvent::ResetUpdateTime();
25196 wxPyEndAllowThreads(__tstate);
25197 if (PyErr_Occurred()) SWIG_fail;
25198 }
25199 resultobj = SWIG_Py_Void();
25200 return resultobj;
25201 fail:
25202 return NULL;
25203 }
25204
25205
25206 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25207 PyObject *resultobj = 0;
25208 wxUpdateUIMode arg1 ;
25209 int val1 ;
25210 int ecode1 = 0 ;
25211 PyObject * obj0 = 0 ;
25212 char * kwnames[] = {
25213 (char *) "mode", NULL
25214 };
25215
25216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25217 ecode1 = SWIG_AsVal_int(obj0, &val1);
25218 if (!SWIG_IsOK(ecode1)) {
25219 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25220 }
25221 arg1 = static_cast< wxUpdateUIMode >(val1);
25222 {
25223 PyThreadState* __tstate = wxPyBeginAllowThreads();
25224 wxUpdateUIEvent::SetMode(arg1);
25225 wxPyEndAllowThreads(__tstate);
25226 if (PyErr_Occurred()) SWIG_fail;
25227 }
25228 resultobj = SWIG_Py_Void();
25229 return resultobj;
25230 fail:
25231 return NULL;
25232 }
25233
25234
25235 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25236 PyObject *resultobj = 0;
25237 wxUpdateUIMode result;
25238
25239 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25240 {
25241 PyThreadState* __tstate = wxPyBeginAllowThreads();
25242 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25243 wxPyEndAllowThreads(__tstate);
25244 if (PyErr_Occurred()) SWIG_fail;
25245 }
25246 resultobj = SWIG_From_int(static_cast< int >(result));
25247 return resultobj;
25248 fail:
25249 return NULL;
25250 }
25251
25252
25253 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25254 PyObject *obj;
25255 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25256 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25257 return SWIG_Py_Void();
25258 }
25259
25260 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25261 return SWIG_Python_InitShadowInstance(args);
25262 }
25263
25264 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25265 PyObject *resultobj = 0;
25266 wxSysColourChangedEvent *result = 0 ;
25267
25268 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25269 {
25270 PyThreadState* __tstate = wxPyBeginAllowThreads();
25271 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25272 wxPyEndAllowThreads(__tstate);
25273 if (PyErr_Occurred()) SWIG_fail;
25274 }
25275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25276 return resultobj;
25277 fail:
25278 return NULL;
25279 }
25280
25281
25282 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25283 PyObject *obj;
25284 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25285 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25286 return SWIG_Py_Void();
25287 }
25288
25289 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25290 return SWIG_Python_InitShadowInstance(args);
25291 }
25292
25293 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25294 PyObject *resultobj = 0;
25295 int arg1 = (int) 0 ;
25296 wxWindow *arg2 = (wxWindow *) NULL ;
25297 wxMouseCaptureChangedEvent *result = 0 ;
25298 int val1 ;
25299 int ecode1 = 0 ;
25300 void *argp2 = 0 ;
25301 int res2 = 0 ;
25302 PyObject * obj0 = 0 ;
25303 PyObject * obj1 = 0 ;
25304 char * kwnames[] = {
25305 (char *) "winid",(char *) "gainedCapture", NULL
25306 };
25307
25308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25309 if (obj0) {
25310 ecode1 = SWIG_AsVal_int(obj0, &val1);
25311 if (!SWIG_IsOK(ecode1)) {
25312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25313 }
25314 arg1 = static_cast< int >(val1);
25315 }
25316 if (obj1) {
25317 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25318 if (!SWIG_IsOK(res2)) {
25319 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25320 }
25321 arg2 = reinterpret_cast< wxWindow * >(argp2);
25322 }
25323 {
25324 PyThreadState* __tstate = wxPyBeginAllowThreads();
25325 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25326 wxPyEndAllowThreads(__tstate);
25327 if (PyErr_Occurred()) SWIG_fail;
25328 }
25329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25330 return resultobj;
25331 fail:
25332 return NULL;
25333 }
25334
25335
25336 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25337 PyObject *resultobj = 0;
25338 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25339 wxWindow *result = 0 ;
25340 void *argp1 = 0 ;
25341 int res1 = 0 ;
25342 PyObject *swig_obj[1] ;
25343
25344 if (!args) SWIG_fail;
25345 swig_obj[0] = args;
25346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25347 if (!SWIG_IsOK(res1)) {
25348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25349 }
25350 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25351 {
25352 PyThreadState* __tstate = wxPyBeginAllowThreads();
25353 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25354 wxPyEndAllowThreads(__tstate);
25355 if (PyErr_Occurred()) SWIG_fail;
25356 }
25357 {
25358 resultobj = wxPyMake_wxObject(result, (bool)0);
25359 }
25360 return resultobj;
25361 fail:
25362 return NULL;
25363 }
25364
25365
25366 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25367 PyObject *obj;
25368 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25369 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25370 return SWIG_Py_Void();
25371 }
25372
25373 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25374 return SWIG_Python_InitShadowInstance(args);
25375 }
25376
25377 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25378 PyObject *resultobj = 0;
25379 wxDisplayChangedEvent *result = 0 ;
25380
25381 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25382 {
25383 PyThreadState* __tstate = wxPyBeginAllowThreads();
25384 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25385 wxPyEndAllowThreads(__tstate);
25386 if (PyErr_Occurred()) SWIG_fail;
25387 }
25388 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25389 return resultobj;
25390 fail:
25391 return NULL;
25392 }
25393
25394
25395 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25396 PyObject *obj;
25397 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25398 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25399 return SWIG_Py_Void();
25400 }
25401
25402 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25403 return SWIG_Python_InitShadowInstance(args);
25404 }
25405
25406 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25407 PyObject *resultobj = 0;
25408 int arg1 = (int) 0 ;
25409 wxPaletteChangedEvent *result = 0 ;
25410 int val1 ;
25411 int ecode1 = 0 ;
25412 PyObject * obj0 = 0 ;
25413 char * kwnames[] = {
25414 (char *) "id", NULL
25415 };
25416
25417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25418 if (obj0) {
25419 ecode1 = SWIG_AsVal_int(obj0, &val1);
25420 if (!SWIG_IsOK(ecode1)) {
25421 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25422 }
25423 arg1 = static_cast< int >(val1);
25424 }
25425 {
25426 PyThreadState* __tstate = wxPyBeginAllowThreads();
25427 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25428 wxPyEndAllowThreads(__tstate);
25429 if (PyErr_Occurred()) SWIG_fail;
25430 }
25431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25432 return resultobj;
25433 fail:
25434 return NULL;
25435 }
25436
25437
25438 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25439 PyObject *resultobj = 0;
25440 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25441 wxWindow *arg2 = (wxWindow *) 0 ;
25442 void *argp1 = 0 ;
25443 int res1 = 0 ;
25444 void *argp2 = 0 ;
25445 int res2 = 0 ;
25446 PyObject * obj0 = 0 ;
25447 PyObject * obj1 = 0 ;
25448 char * kwnames[] = {
25449 (char *) "self",(char *) "win", NULL
25450 };
25451
25452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25454 if (!SWIG_IsOK(res1)) {
25455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25456 }
25457 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25458 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25459 if (!SWIG_IsOK(res2)) {
25460 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25461 }
25462 arg2 = reinterpret_cast< wxWindow * >(argp2);
25463 {
25464 PyThreadState* __tstate = wxPyBeginAllowThreads();
25465 (arg1)->SetChangedWindow(arg2);
25466 wxPyEndAllowThreads(__tstate);
25467 if (PyErr_Occurred()) SWIG_fail;
25468 }
25469 resultobj = SWIG_Py_Void();
25470 return resultobj;
25471 fail:
25472 return NULL;
25473 }
25474
25475
25476 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25477 PyObject *resultobj = 0;
25478 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25479 wxWindow *result = 0 ;
25480 void *argp1 = 0 ;
25481 int res1 = 0 ;
25482 PyObject *swig_obj[1] ;
25483
25484 if (!args) SWIG_fail;
25485 swig_obj[0] = args;
25486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25487 if (!SWIG_IsOK(res1)) {
25488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25489 }
25490 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25491 {
25492 PyThreadState* __tstate = wxPyBeginAllowThreads();
25493 result = (wxWindow *)(arg1)->GetChangedWindow();
25494 wxPyEndAllowThreads(__tstate);
25495 if (PyErr_Occurred()) SWIG_fail;
25496 }
25497 {
25498 resultobj = wxPyMake_wxObject(result, (bool)0);
25499 }
25500 return resultobj;
25501 fail:
25502 return NULL;
25503 }
25504
25505
25506 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25507 PyObject *obj;
25508 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25509 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25510 return SWIG_Py_Void();
25511 }
25512
25513 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25514 return SWIG_Python_InitShadowInstance(args);
25515 }
25516
25517 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25518 PyObject *resultobj = 0;
25519 int arg1 = (int) 0 ;
25520 wxQueryNewPaletteEvent *result = 0 ;
25521 int val1 ;
25522 int ecode1 = 0 ;
25523 PyObject * obj0 = 0 ;
25524 char * kwnames[] = {
25525 (char *) "winid", NULL
25526 };
25527
25528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25529 if (obj0) {
25530 ecode1 = SWIG_AsVal_int(obj0, &val1);
25531 if (!SWIG_IsOK(ecode1)) {
25532 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25533 }
25534 arg1 = static_cast< int >(val1);
25535 }
25536 {
25537 PyThreadState* __tstate = wxPyBeginAllowThreads();
25538 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25539 wxPyEndAllowThreads(__tstate);
25540 if (PyErr_Occurred()) SWIG_fail;
25541 }
25542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25543 return resultobj;
25544 fail:
25545 return NULL;
25546 }
25547
25548
25549 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25550 PyObject *resultobj = 0;
25551 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25552 bool arg2 ;
25553 void *argp1 = 0 ;
25554 int res1 = 0 ;
25555 bool val2 ;
25556 int ecode2 = 0 ;
25557 PyObject * obj0 = 0 ;
25558 PyObject * obj1 = 0 ;
25559 char * kwnames[] = {
25560 (char *) "self",(char *) "realized", NULL
25561 };
25562
25563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25565 if (!SWIG_IsOK(res1)) {
25566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25567 }
25568 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25569 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25570 if (!SWIG_IsOK(ecode2)) {
25571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25572 }
25573 arg2 = static_cast< bool >(val2);
25574 {
25575 PyThreadState* __tstate = wxPyBeginAllowThreads();
25576 (arg1)->SetPaletteRealized(arg2);
25577 wxPyEndAllowThreads(__tstate);
25578 if (PyErr_Occurred()) SWIG_fail;
25579 }
25580 resultobj = SWIG_Py_Void();
25581 return resultobj;
25582 fail:
25583 return NULL;
25584 }
25585
25586
25587 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25588 PyObject *resultobj = 0;
25589 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25590 bool result;
25591 void *argp1 = 0 ;
25592 int res1 = 0 ;
25593 PyObject *swig_obj[1] ;
25594
25595 if (!args) SWIG_fail;
25596 swig_obj[0] = args;
25597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25598 if (!SWIG_IsOK(res1)) {
25599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25600 }
25601 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25602 {
25603 PyThreadState* __tstate = wxPyBeginAllowThreads();
25604 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25605 wxPyEndAllowThreads(__tstate);
25606 if (PyErr_Occurred()) SWIG_fail;
25607 }
25608 {
25609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25610 }
25611 return resultobj;
25612 fail:
25613 return NULL;
25614 }
25615
25616
25617 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25618 PyObject *obj;
25619 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25620 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25621 return SWIG_Py_Void();
25622 }
25623
25624 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25625 return SWIG_Python_InitShadowInstance(args);
25626 }
25627
25628 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25629 PyObject *resultobj = 0;
25630 wxNavigationKeyEvent *result = 0 ;
25631
25632 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25633 {
25634 PyThreadState* __tstate = wxPyBeginAllowThreads();
25635 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25636 wxPyEndAllowThreads(__tstate);
25637 if (PyErr_Occurred()) SWIG_fail;
25638 }
25639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25640 return resultobj;
25641 fail:
25642 return NULL;
25643 }
25644
25645
25646 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25647 PyObject *resultobj = 0;
25648 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25649 bool result;
25650 void *argp1 = 0 ;
25651 int res1 = 0 ;
25652 PyObject *swig_obj[1] ;
25653
25654 if (!args) SWIG_fail;
25655 swig_obj[0] = args;
25656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25657 if (!SWIG_IsOK(res1)) {
25658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25659 }
25660 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25661 {
25662 PyThreadState* __tstate = wxPyBeginAllowThreads();
25663 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25664 wxPyEndAllowThreads(__tstate);
25665 if (PyErr_Occurred()) SWIG_fail;
25666 }
25667 {
25668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25669 }
25670 return resultobj;
25671 fail:
25672 return NULL;
25673 }
25674
25675
25676 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25677 PyObject *resultobj = 0;
25678 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25679 bool arg2 ;
25680 void *argp1 = 0 ;
25681 int res1 = 0 ;
25682 bool val2 ;
25683 int ecode2 = 0 ;
25684 PyObject * obj0 = 0 ;
25685 PyObject * obj1 = 0 ;
25686 char * kwnames[] = {
25687 (char *) "self",(char *) "forward", NULL
25688 };
25689
25690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25692 if (!SWIG_IsOK(res1)) {
25693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25694 }
25695 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25696 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25697 if (!SWIG_IsOK(ecode2)) {
25698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25699 }
25700 arg2 = static_cast< bool >(val2);
25701 {
25702 PyThreadState* __tstate = wxPyBeginAllowThreads();
25703 (arg1)->SetDirection(arg2);
25704 wxPyEndAllowThreads(__tstate);
25705 if (PyErr_Occurred()) SWIG_fail;
25706 }
25707 resultobj = SWIG_Py_Void();
25708 return resultobj;
25709 fail:
25710 return NULL;
25711 }
25712
25713
25714 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25715 PyObject *resultobj = 0;
25716 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25717 bool result;
25718 void *argp1 = 0 ;
25719 int res1 = 0 ;
25720 PyObject *swig_obj[1] ;
25721
25722 if (!args) SWIG_fail;
25723 swig_obj[0] = args;
25724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25725 if (!SWIG_IsOK(res1)) {
25726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25727 }
25728 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25729 {
25730 PyThreadState* __tstate = wxPyBeginAllowThreads();
25731 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25732 wxPyEndAllowThreads(__tstate);
25733 if (PyErr_Occurred()) SWIG_fail;
25734 }
25735 {
25736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25737 }
25738 return resultobj;
25739 fail:
25740 return NULL;
25741 }
25742
25743
25744 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25745 PyObject *resultobj = 0;
25746 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25747 bool arg2 ;
25748 void *argp1 = 0 ;
25749 int res1 = 0 ;
25750 bool val2 ;
25751 int ecode2 = 0 ;
25752 PyObject * obj0 = 0 ;
25753 PyObject * obj1 = 0 ;
25754 char * kwnames[] = {
25755 (char *) "self",(char *) "ischange", NULL
25756 };
25757
25758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25760 if (!SWIG_IsOK(res1)) {
25761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25762 }
25763 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25764 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25765 if (!SWIG_IsOK(ecode2)) {
25766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25767 }
25768 arg2 = static_cast< bool >(val2);
25769 {
25770 PyThreadState* __tstate = wxPyBeginAllowThreads();
25771 (arg1)->SetWindowChange(arg2);
25772 wxPyEndAllowThreads(__tstate);
25773 if (PyErr_Occurred()) SWIG_fail;
25774 }
25775 resultobj = SWIG_Py_Void();
25776 return resultobj;
25777 fail:
25778 return NULL;
25779 }
25780
25781
25782 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25783 PyObject *resultobj = 0;
25784 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25785 bool result;
25786 void *argp1 = 0 ;
25787 int res1 = 0 ;
25788 PyObject *swig_obj[1] ;
25789
25790 if (!args) SWIG_fail;
25791 swig_obj[0] = args;
25792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25793 if (!SWIG_IsOK(res1)) {
25794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25795 }
25796 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25797 {
25798 PyThreadState* __tstate = wxPyBeginAllowThreads();
25799 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25800 wxPyEndAllowThreads(__tstate);
25801 if (PyErr_Occurred()) SWIG_fail;
25802 }
25803 {
25804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25805 }
25806 return resultobj;
25807 fail:
25808 return NULL;
25809 }
25810
25811
25812 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25813 PyObject *resultobj = 0;
25814 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25815 bool arg2 ;
25816 void *argp1 = 0 ;
25817 int res1 = 0 ;
25818 bool val2 ;
25819 int ecode2 = 0 ;
25820 PyObject * obj0 = 0 ;
25821 PyObject * obj1 = 0 ;
25822 char * kwnames[] = {
25823 (char *) "self",(char *) "bIs", NULL
25824 };
25825
25826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25828 if (!SWIG_IsOK(res1)) {
25829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25830 }
25831 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25832 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25833 if (!SWIG_IsOK(ecode2)) {
25834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25835 }
25836 arg2 = static_cast< bool >(val2);
25837 {
25838 PyThreadState* __tstate = wxPyBeginAllowThreads();
25839 (arg1)->SetFromTab(arg2);
25840 wxPyEndAllowThreads(__tstate);
25841 if (PyErr_Occurred()) SWIG_fail;
25842 }
25843 resultobj = SWIG_Py_Void();
25844 return resultobj;
25845 fail:
25846 return NULL;
25847 }
25848
25849
25850 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25851 PyObject *resultobj = 0;
25852 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25853 long arg2 ;
25854 void *argp1 = 0 ;
25855 int res1 = 0 ;
25856 long val2 ;
25857 int ecode2 = 0 ;
25858 PyObject * obj0 = 0 ;
25859 PyObject * obj1 = 0 ;
25860 char * kwnames[] = {
25861 (char *) "self",(char *) "flags", NULL
25862 };
25863
25864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25866 if (!SWIG_IsOK(res1)) {
25867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25868 }
25869 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25870 ecode2 = SWIG_AsVal_long(obj1, &val2);
25871 if (!SWIG_IsOK(ecode2)) {
25872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25873 }
25874 arg2 = static_cast< long >(val2);
25875 {
25876 PyThreadState* __tstate = wxPyBeginAllowThreads();
25877 (arg1)->SetFlags(arg2);
25878 wxPyEndAllowThreads(__tstate);
25879 if (PyErr_Occurred()) SWIG_fail;
25880 }
25881 resultobj = SWIG_Py_Void();
25882 return resultobj;
25883 fail:
25884 return NULL;
25885 }
25886
25887
25888 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25889 PyObject *resultobj = 0;
25890 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25891 wxWindow *result = 0 ;
25892 void *argp1 = 0 ;
25893 int res1 = 0 ;
25894 PyObject *swig_obj[1] ;
25895
25896 if (!args) SWIG_fail;
25897 swig_obj[0] = args;
25898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25899 if (!SWIG_IsOK(res1)) {
25900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25901 }
25902 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25903 {
25904 PyThreadState* __tstate = wxPyBeginAllowThreads();
25905 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25906 wxPyEndAllowThreads(__tstate);
25907 if (PyErr_Occurred()) SWIG_fail;
25908 }
25909 {
25910 resultobj = wxPyMake_wxObject(result, (bool)0);
25911 }
25912 return resultobj;
25913 fail:
25914 return NULL;
25915 }
25916
25917
25918 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25919 PyObject *resultobj = 0;
25920 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25921 wxWindow *arg2 = (wxWindow *) 0 ;
25922 void *argp1 = 0 ;
25923 int res1 = 0 ;
25924 void *argp2 = 0 ;
25925 int res2 = 0 ;
25926 PyObject * obj0 = 0 ;
25927 PyObject * obj1 = 0 ;
25928 char * kwnames[] = {
25929 (char *) "self",(char *) "win", NULL
25930 };
25931
25932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25934 if (!SWIG_IsOK(res1)) {
25935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25936 }
25937 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25938 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25939 if (!SWIG_IsOK(res2)) {
25940 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25941 }
25942 arg2 = reinterpret_cast< wxWindow * >(argp2);
25943 {
25944 PyThreadState* __tstate = wxPyBeginAllowThreads();
25945 (arg1)->SetCurrentFocus(arg2);
25946 wxPyEndAllowThreads(__tstate);
25947 if (PyErr_Occurred()) SWIG_fail;
25948 }
25949 resultobj = SWIG_Py_Void();
25950 return resultobj;
25951 fail:
25952 return NULL;
25953 }
25954
25955
25956 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25957 PyObject *obj;
25958 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25959 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25960 return SWIG_Py_Void();
25961 }
25962
25963 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25964 return SWIG_Python_InitShadowInstance(args);
25965 }
25966
25967 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25968 PyObject *resultobj = 0;
25969 wxWindow *arg1 = (wxWindow *) NULL ;
25970 wxWindowCreateEvent *result = 0 ;
25971 void *argp1 = 0 ;
25972 int res1 = 0 ;
25973 PyObject * obj0 = 0 ;
25974 char * kwnames[] = {
25975 (char *) "win", NULL
25976 };
25977
25978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25979 if (obj0) {
25980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25981 if (!SWIG_IsOK(res1)) {
25982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25983 }
25984 arg1 = reinterpret_cast< wxWindow * >(argp1);
25985 }
25986 {
25987 PyThreadState* __tstate = wxPyBeginAllowThreads();
25988 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25989 wxPyEndAllowThreads(__tstate);
25990 if (PyErr_Occurred()) SWIG_fail;
25991 }
25992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25993 return resultobj;
25994 fail:
25995 return NULL;
25996 }
25997
25998
25999 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26000 PyObject *resultobj = 0;
26001 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26002 wxWindow *result = 0 ;
26003 void *argp1 = 0 ;
26004 int res1 = 0 ;
26005 PyObject *swig_obj[1] ;
26006
26007 if (!args) SWIG_fail;
26008 swig_obj[0] = args;
26009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26010 if (!SWIG_IsOK(res1)) {
26011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26012 }
26013 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26014 {
26015 PyThreadState* __tstate = wxPyBeginAllowThreads();
26016 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26017 wxPyEndAllowThreads(__tstate);
26018 if (PyErr_Occurred()) SWIG_fail;
26019 }
26020 {
26021 resultobj = wxPyMake_wxObject(result, (bool)0);
26022 }
26023 return resultobj;
26024 fail:
26025 return NULL;
26026 }
26027
26028
26029 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26030 PyObject *obj;
26031 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26032 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26033 return SWIG_Py_Void();
26034 }
26035
26036 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26037 return SWIG_Python_InitShadowInstance(args);
26038 }
26039
26040 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26041 PyObject *resultobj = 0;
26042 wxWindow *arg1 = (wxWindow *) NULL ;
26043 wxWindowDestroyEvent *result = 0 ;
26044 void *argp1 = 0 ;
26045 int res1 = 0 ;
26046 PyObject * obj0 = 0 ;
26047 char * kwnames[] = {
26048 (char *) "win", NULL
26049 };
26050
26051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26052 if (obj0) {
26053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26054 if (!SWIG_IsOK(res1)) {
26055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26056 }
26057 arg1 = reinterpret_cast< wxWindow * >(argp1);
26058 }
26059 {
26060 PyThreadState* __tstate = wxPyBeginAllowThreads();
26061 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26062 wxPyEndAllowThreads(__tstate);
26063 if (PyErr_Occurred()) SWIG_fail;
26064 }
26065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26066 return resultobj;
26067 fail:
26068 return NULL;
26069 }
26070
26071
26072 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26073 PyObject *resultobj = 0;
26074 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26075 wxWindow *result = 0 ;
26076 void *argp1 = 0 ;
26077 int res1 = 0 ;
26078 PyObject *swig_obj[1] ;
26079
26080 if (!args) SWIG_fail;
26081 swig_obj[0] = args;
26082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26083 if (!SWIG_IsOK(res1)) {
26084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26085 }
26086 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26087 {
26088 PyThreadState* __tstate = wxPyBeginAllowThreads();
26089 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26090 wxPyEndAllowThreads(__tstate);
26091 if (PyErr_Occurred()) SWIG_fail;
26092 }
26093 {
26094 resultobj = wxPyMake_wxObject(result, (bool)0);
26095 }
26096 return resultobj;
26097 fail:
26098 return NULL;
26099 }
26100
26101
26102 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26103 PyObject *obj;
26104 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26105 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26106 return SWIG_Py_Void();
26107 }
26108
26109 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26110 return SWIG_Python_InitShadowInstance(args);
26111 }
26112
26113 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26114 PyObject *resultobj = 0;
26115 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26116 int arg2 = (int) 0 ;
26117 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26118 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26119 wxContextMenuEvent *result = 0 ;
26120 int val1 ;
26121 int ecode1 = 0 ;
26122 int val2 ;
26123 int ecode2 = 0 ;
26124 wxPoint temp3 ;
26125 PyObject * obj0 = 0 ;
26126 PyObject * obj1 = 0 ;
26127 PyObject * obj2 = 0 ;
26128 char * kwnames[] = {
26129 (char *) "type",(char *) "winid",(char *) "pt", NULL
26130 };
26131
26132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26133 if (obj0) {
26134 ecode1 = SWIG_AsVal_int(obj0, &val1);
26135 if (!SWIG_IsOK(ecode1)) {
26136 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26137 }
26138 arg1 = static_cast< wxEventType >(val1);
26139 }
26140 if (obj1) {
26141 ecode2 = SWIG_AsVal_int(obj1, &val2);
26142 if (!SWIG_IsOK(ecode2)) {
26143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26144 }
26145 arg2 = static_cast< int >(val2);
26146 }
26147 if (obj2) {
26148 {
26149 arg3 = &temp3;
26150 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26151 }
26152 }
26153 {
26154 PyThreadState* __tstate = wxPyBeginAllowThreads();
26155 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26156 wxPyEndAllowThreads(__tstate);
26157 if (PyErr_Occurred()) SWIG_fail;
26158 }
26159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26160 return resultobj;
26161 fail:
26162 return NULL;
26163 }
26164
26165
26166 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26167 PyObject *resultobj = 0;
26168 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26169 wxPoint *result = 0 ;
26170 void *argp1 = 0 ;
26171 int res1 = 0 ;
26172 PyObject *swig_obj[1] ;
26173
26174 if (!args) SWIG_fail;
26175 swig_obj[0] = args;
26176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26177 if (!SWIG_IsOK(res1)) {
26178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26179 }
26180 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26181 {
26182 PyThreadState* __tstate = wxPyBeginAllowThreads();
26183 {
26184 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26185 result = (wxPoint *) &_result_ref;
26186 }
26187 wxPyEndAllowThreads(__tstate);
26188 if (PyErr_Occurred()) SWIG_fail;
26189 }
26190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26191 return resultobj;
26192 fail:
26193 return NULL;
26194 }
26195
26196
26197 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26198 PyObject *resultobj = 0;
26199 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26200 wxPoint *arg2 = 0 ;
26201 void *argp1 = 0 ;
26202 int res1 = 0 ;
26203 wxPoint temp2 ;
26204 PyObject * obj0 = 0 ;
26205 PyObject * obj1 = 0 ;
26206 char * kwnames[] = {
26207 (char *) "self",(char *) "pos", NULL
26208 };
26209
26210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26212 if (!SWIG_IsOK(res1)) {
26213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26214 }
26215 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26216 {
26217 arg2 = &temp2;
26218 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26219 }
26220 {
26221 PyThreadState* __tstate = wxPyBeginAllowThreads();
26222 (arg1)->SetPosition((wxPoint const &)*arg2);
26223 wxPyEndAllowThreads(__tstate);
26224 if (PyErr_Occurred()) SWIG_fail;
26225 }
26226 resultobj = SWIG_Py_Void();
26227 return resultobj;
26228 fail:
26229 return NULL;
26230 }
26231
26232
26233 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26234 PyObject *obj;
26235 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26236 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26237 return SWIG_Py_Void();
26238 }
26239
26240 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26241 return SWIG_Python_InitShadowInstance(args);
26242 }
26243
26244 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26245 PyObject *resultobj = 0;
26246 wxIdleEvent *result = 0 ;
26247
26248 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26249 {
26250 PyThreadState* __tstate = wxPyBeginAllowThreads();
26251 result = (wxIdleEvent *)new wxIdleEvent();
26252 wxPyEndAllowThreads(__tstate);
26253 if (PyErr_Occurred()) SWIG_fail;
26254 }
26255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26256 return resultobj;
26257 fail:
26258 return NULL;
26259 }
26260
26261
26262 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26263 PyObject *resultobj = 0;
26264 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26265 bool arg2 = (bool) true ;
26266 void *argp1 = 0 ;
26267 int res1 = 0 ;
26268 bool val2 ;
26269 int ecode2 = 0 ;
26270 PyObject * obj0 = 0 ;
26271 PyObject * obj1 = 0 ;
26272 char * kwnames[] = {
26273 (char *) "self",(char *) "needMore", NULL
26274 };
26275
26276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26278 if (!SWIG_IsOK(res1)) {
26279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26280 }
26281 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26282 if (obj1) {
26283 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26284 if (!SWIG_IsOK(ecode2)) {
26285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26286 }
26287 arg2 = static_cast< bool >(val2);
26288 }
26289 {
26290 PyThreadState* __tstate = wxPyBeginAllowThreads();
26291 (arg1)->RequestMore(arg2);
26292 wxPyEndAllowThreads(__tstate);
26293 if (PyErr_Occurred()) SWIG_fail;
26294 }
26295 resultobj = SWIG_Py_Void();
26296 return resultobj;
26297 fail:
26298 return NULL;
26299 }
26300
26301
26302 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26303 PyObject *resultobj = 0;
26304 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26305 bool result;
26306 void *argp1 = 0 ;
26307 int res1 = 0 ;
26308 PyObject *swig_obj[1] ;
26309
26310 if (!args) SWIG_fail;
26311 swig_obj[0] = args;
26312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26313 if (!SWIG_IsOK(res1)) {
26314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26315 }
26316 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26317 {
26318 PyThreadState* __tstate = wxPyBeginAllowThreads();
26319 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26320 wxPyEndAllowThreads(__tstate);
26321 if (PyErr_Occurred()) SWIG_fail;
26322 }
26323 {
26324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26325 }
26326 return resultobj;
26327 fail:
26328 return NULL;
26329 }
26330
26331
26332 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26333 PyObject *resultobj = 0;
26334 wxIdleMode arg1 ;
26335 int val1 ;
26336 int ecode1 = 0 ;
26337 PyObject * obj0 = 0 ;
26338 char * kwnames[] = {
26339 (char *) "mode", NULL
26340 };
26341
26342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26343 ecode1 = SWIG_AsVal_int(obj0, &val1);
26344 if (!SWIG_IsOK(ecode1)) {
26345 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26346 }
26347 arg1 = static_cast< wxIdleMode >(val1);
26348 {
26349 PyThreadState* __tstate = wxPyBeginAllowThreads();
26350 wxIdleEvent::SetMode(arg1);
26351 wxPyEndAllowThreads(__tstate);
26352 if (PyErr_Occurred()) SWIG_fail;
26353 }
26354 resultobj = SWIG_Py_Void();
26355 return resultobj;
26356 fail:
26357 return NULL;
26358 }
26359
26360
26361 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26362 PyObject *resultobj = 0;
26363 wxIdleMode result;
26364
26365 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26366 {
26367 PyThreadState* __tstate = wxPyBeginAllowThreads();
26368 result = (wxIdleMode)wxIdleEvent::GetMode();
26369 wxPyEndAllowThreads(__tstate);
26370 if (PyErr_Occurred()) SWIG_fail;
26371 }
26372 resultobj = SWIG_From_int(static_cast< int >(result));
26373 return resultobj;
26374 fail:
26375 return NULL;
26376 }
26377
26378
26379 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26380 PyObject *resultobj = 0;
26381 wxWindow *arg1 = (wxWindow *) 0 ;
26382 bool result;
26383 void *argp1 = 0 ;
26384 int res1 = 0 ;
26385 PyObject * obj0 = 0 ;
26386 char * kwnames[] = {
26387 (char *) "win", NULL
26388 };
26389
26390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26392 if (!SWIG_IsOK(res1)) {
26393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26394 }
26395 arg1 = reinterpret_cast< wxWindow * >(argp1);
26396 {
26397 PyThreadState* __tstate = wxPyBeginAllowThreads();
26398 result = (bool)wxIdleEvent::CanSend(arg1);
26399 wxPyEndAllowThreads(__tstate);
26400 if (PyErr_Occurred()) SWIG_fail;
26401 }
26402 {
26403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26404 }
26405 return resultobj;
26406 fail:
26407 return NULL;
26408 }
26409
26410
26411 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26412 PyObject *obj;
26413 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26414 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26415 return SWIG_Py_Void();
26416 }
26417
26418 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26419 return SWIG_Python_InitShadowInstance(args);
26420 }
26421
26422 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26423 PyObject *resultobj = 0;
26424 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26425 int arg2 = (int) 0 ;
26426 wxClipboardTextEvent *result = 0 ;
26427 int val1 ;
26428 int ecode1 = 0 ;
26429 int val2 ;
26430 int ecode2 = 0 ;
26431 PyObject * obj0 = 0 ;
26432 PyObject * obj1 = 0 ;
26433 char * kwnames[] = {
26434 (char *) "type",(char *) "winid", NULL
26435 };
26436
26437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26438 if (obj0) {
26439 ecode1 = SWIG_AsVal_int(obj0, &val1);
26440 if (!SWIG_IsOK(ecode1)) {
26441 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26442 }
26443 arg1 = static_cast< wxEventType >(val1);
26444 }
26445 if (obj1) {
26446 ecode2 = SWIG_AsVal_int(obj1, &val2);
26447 if (!SWIG_IsOK(ecode2)) {
26448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26449 }
26450 arg2 = static_cast< int >(val2);
26451 }
26452 {
26453 PyThreadState* __tstate = wxPyBeginAllowThreads();
26454 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26455 wxPyEndAllowThreads(__tstate);
26456 if (PyErr_Occurred()) SWIG_fail;
26457 }
26458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26459 return resultobj;
26460 fail:
26461 return NULL;
26462 }
26463
26464
26465 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26466 PyObject *obj;
26467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26468 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26469 return SWIG_Py_Void();
26470 }
26471
26472 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26473 return SWIG_Python_InitShadowInstance(args);
26474 }
26475
26476 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26477 PyObject *resultobj = 0;
26478 int arg1 = (int) 0 ;
26479 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26480 wxPyEvent *result = 0 ;
26481 int val1 ;
26482 int ecode1 = 0 ;
26483 int val2 ;
26484 int ecode2 = 0 ;
26485 PyObject * obj0 = 0 ;
26486 PyObject * obj1 = 0 ;
26487 char * kwnames[] = {
26488 (char *) "winid",(char *) "eventType", NULL
26489 };
26490
26491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26492 if (obj0) {
26493 ecode1 = SWIG_AsVal_int(obj0, &val1);
26494 if (!SWIG_IsOK(ecode1)) {
26495 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26496 }
26497 arg1 = static_cast< int >(val1);
26498 }
26499 if (obj1) {
26500 ecode2 = SWIG_AsVal_int(obj1, &val2);
26501 if (!SWIG_IsOK(ecode2)) {
26502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26503 }
26504 arg2 = static_cast< wxEventType >(val2);
26505 }
26506 {
26507 PyThreadState* __tstate = wxPyBeginAllowThreads();
26508 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26509 wxPyEndAllowThreads(__tstate);
26510 if (PyErr_Occurred()) SWIG_fail;
26511 }
26512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26513 return resultobj;
26514 fail:
26515 return NULL;
26516 }
26517
26518
26519 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26520 PyObject *resultobj = 0;
26521 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26522 void *argp1 = 0 ;
26523 int res1 = 0 ;
26524 PyObject *swig_obj[1] ;
26525
26526 if (!args) SWIG_fail;
26527 swig_obj[0] = args;
26528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26529 if (!SWIG_IsOK(res1)) {
26530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26531 }
26532 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26533 {
26534 PyThreadState* __tstate = wxPyBeginAllowThreads();
26535 delete arg1;
26536
26537 wxPyEndAllowThreads(__tstate);
26538 if (PyErr_Occurred()) SWIG_fail;
26539 }
26540 resultobj = SWIG_Py_Void();
26541 return resultobj;
26542 fail:
26543 return NULL;
26544 }
26545
26546
26547 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26548 PyObject *resultobj = 0;
26549 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26550 PyObject *arg2 = (PyObject *) 0 ;
26551 void *argp1 = 0 ;
26552 int res1 = 0 ;
26553 PyObject * obj0 = 0 ;
26554 PyObject * obj1 = 0 ;
26555 char * kwnames[] = {
26556 (char *) "self",(char *) "self", NULL
26557 };
26558
26559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26561 if (!SWIG_IsOK(res1)) {
26562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26563 }
26564 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26565 arg2 = obj1;
26566 {
26567 PyThreadState* __tstate = wxPyBeginAllowThreads();
26568 (arg1)->SetSelf(arg2);
26569 wxPyEndAllowThreads(__tstate);
26570 if (PyErr_Occurred()) SWIG_fail;
26571 }
26572 resultobj = SWIG_Py_Void();
26573 return resultobj;
26574 fail:
26575 return NULL;
26576 }
26577
26578
26579 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26580 PyObject *resultobj = 0;
26581 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26582 PyObject *result = 0 ;
26583 void *argp1 = 0 ;
26584 int res1 = 0 ;
26585 PyObject *swig_obj[1] ;
26586
26587 if (!args) SWIG_fail;
26588 swig_obj[0] = args;
26589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26590 if (!SWIG_IsOK(res1)) {
26591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26592 }
26593 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26594 {
26595 PyThreadState* __tstate = wxPyBeginAllowThreads();
26596 result = (PyObject *)(arg1)->GetSelf();
26597 wxPyEndAllowThreads(__tstate);
26598 if (PyErr_Occurred()) SWIG_fail;
26599 }
26600 resultobj = result;
26601 return resultobj;
26602 fail:
26603 return NULL;
26604 }
26605
26606
26607 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26608 PyObject *obj;
26609 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26610 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26611 return SWIG_Py_Void();
26612 }
26613
26614 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26615 return SWIG_Python_InitShadowInstance(args);
26616 }
26617
26618 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26619 PyObject *resultobj = 0;
26620 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26621 int arg2 = (int) 0 ;
26622 wxPyCommandEvent *result = 0 ;
26623 int val1 ;
26624 int ecode1 = 0 ;
26625 int val2 ;
26626 int ecode2 = 0 ;
26627 PyObject * obj0 = 0 ;
26628 PyObject * obj1 = 0 ;
26629 char * kwnames[] = {
26630 (char *) "eventType",(char *) "id", NULL
26631 };
26632
26633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26634 if (obj0) {
26635 ecode1 = SWIG_AsVal_int(obj0, &val1);
26636 if (!SWIG_IsOK(ecode1)) {
26637 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26638 }
26639 arg1 = static_cast< wxEventType >(val1);
26640 }
26641 if (obj1) {
26642 ecode2 = SWIG_AsVal_int(obj1, &val2);
26643 if (!SWIG_IsOK(ecode2)) {
26644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26645 }
26646 arg2 = static_cast< int >(val2);
26647 }
26648 {
26649 PyThreadState* __tstate = wxPyBeginAllowThreads();
26650 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26651 wxPyEndAllowThreads(__tstate);
26652 if (PyErr_Occurred()) SWIG_fail;
26653 }
26654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26655 return resultobj;
26656 fail:
26657 return NULL;
26658 }
26659
26660
26661 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26662 PyObject *resultobj = 0;
26663 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26664 void *argp1 = 0 ;
26665 int res1 = 0 ;
26666 PyObject *swig_obj[1] ;
26667
26668 if (!args) SWIG_fail;
26669 swig_obj[0] = args;
26670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26671 if (!SWIG_IsOK(res1)) {
26672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26673 }
26674 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26675 {
26676 PyThreadState* __tstate = wxPyBeginAllowThreads();
26677 delete arg1;
26678
26679 wxPyEndAllowThreads(__tstate);
26680 if (PyErr_Occurred()) SWIG_fail;
26681 }
26682 resultobj = SWIG_Py_Void();
26683 return resultobj;
26684 fail:
26685 return NULL;
26686 }
26687
26688
26689 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26690 PyObject *resultobj = 0;
26691 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26692 PyObject *arg2 = (PyObject *) 0 ;
26693 void *argp1 = 0 ;
26694 int res1 = 0 ;
26695 PyObject * obj0 = 0 ;
26696 PyObject * obj1 = 0 ;
26697 char * kwnames[] = {
26698 (char *) "self",(char *) "self", NULL
26699 };
26700
26701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26703 if (!SWIG_IsOK(res1)) {
26704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26705 }
26706 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26707 arg2 = obj1;
26708 {
26709 PyThreadState* __tstate = wxPyBeginAllowThreads();
26710 (arg1)->SetSelf(arg2);
26711 wxPyEndAllowThreads(__tstate);
26712 if (PyErr_Occurred()) SWIG_fail;
26713 }
26714 resultobj = SWIG_Py_Void();
26715 return resultobj;
26716 fail:
26717 return NULL;
26718 }
26719
26720
26721 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26722 PyObject *resultobj = 0;
26723 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26724 PyObject *result = 0 ;
26725 void *argp1 = 0 ;
26726 int res1 = 0 ;
26727 PyObject *swig_obj[1] ;
26728
26729 if (!args) SWIG_fail;
26730 swig_obj[0] = args;
26731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26732 if (!SWIG_IsOK(res1)) {
26733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26734 }
26735 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26736 {
26737 PyThreadState* __tstate = wxPyBeginAllowThreads();
26738 result = (PyObject *)(arg1)->GetSelf();
26739 wxPyEndAllowThreads(__tstate);
26740 if (PyErr_Occurred()) SWIG_fail;
26741 }
26742 resultobj = result;
26743 return resultobj;
26744 fail:
26745 return NULL;
26746 }
26747
26748
26749 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26750 PyObject *obj;
26751 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26752 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26753 return SWIG_Py_Void();
26754 }
26755
26756 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26757 return SWIG_Python_InitShadowInstance(args);
26758 }
26759
26760 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26761 PyObject *resultobj = 0;
26762 wxWindow *arg1 = (wxWindow *) 0 ;
26763 wxDateTime *arg2 = 0 ;
26764 wxEventType arg3 ;
26765 wxDateEvent *result = 0 ;
26766 void *argp1 = 0 ;
26767 int res1 = 0 ;
26768 void *argp2 = 0 ;
26769 int res2 = 0 ;
26770 int val3 ;
26771 int ecode3 = 0 ;
26772 PyObject * obj0 = 0 ;
26773 PyObject * obj1 = 0 ;
26774 PyObject * obj2 = 0 ;
26775 char * kwnames[] = {
26776 (char *) "win",(char *) "dt",(char *) "type", NULL
26777 };
26778
26779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26781 if (!SWIG_IsOK(res1)) {
26782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26783 }
26784 arg1 = reinterpret_cast< wxWindow * >(argp1);
26785 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26786 if (!SWIG_IsOK(res2)) {
26787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26788 }
26789 if (!argp2) {
26790 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26791 }
26792 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26793 ecode3 = SWIG_AsVal_int(obj2, &val3);
26794 if (!SWIG_IsOK(ecode3)) {
26795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26796 }
26797 arg3 = static_cast< wxEventType >(val3);
26798 {
26799 PyThreadState* __tstate = wxPyBeginAllowThreads();
26800 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26801 wxPyEndAllowThreads(__tstate);
26802 if (PyErr_Occurred()) SWIG_fail;
26803 }
26804 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26805 return resultobj;
26806 fail:
26807 return NULL;
26808 }
26809
26810
26811 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26812 PyObject *resultobj = 0;
26813 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26814 wxDateTime *result = 0 ;
26815 void *argp1 = 0 ;
26816 int res1 = 0 ;
26817 PyObject *swig_obj[1] ;
26818
26819 if (!args) SWIG_fail;
26820 swig_obj[0] = args;
26821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26822 if (!SWIG_IsOK(res1)) {
26823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26824 }
26825 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26826 {
26827 PyThreadState* __tstate = wxPyBeginAllowThreads();
26828 {
26829 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26830 result = (wxDateTime *) &_result_ref;
26831 }
26832 wxPyEndAllowThreads(__tstate);
26833 if (PyErr_Occurred()) SWIG_fail;
26834 }
26835 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26836 return resultobj;
26837 fail:
26838 return NULL;
26839 }
26840
26841
26842 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26843 PyObject *resultobj = 0;
26844 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26845 wxDateTime *arg2 = 0 ;
26846 void *argp1 = 0 ;
26847 int res1 = 0 ;
26848 void *argp2 = 0 ;
26849 int res2 = 0 ;
26850 PyObject * obj0 = 0 ;
26851 PyObject * obj1 = 0 ;
26852 char * kwnames[] = {
26853 (char *) "self",(char *) "date", NULL
26854 };
26855
26856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26858 if (!SWIG_IsOK(res1)) {
26859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26860 }
26861 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26862 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26863 if (!SWIG_IsOK(res2)) {
26864 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26865 }
26866 if (!argp2) {
26867 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26868 }
26869 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26870 {
26871 PyThreadState* __tstate = wxPyBeginAllowThreads();
26872 (arg1)->SetDate((wxDateTime const &)*arg2);
26873 wxPyEndAllowThreads(__tstate);
26874 if (PyErr_Occurred()) SWIG_fail;
26875 }
26876 resultobj = SWIG_Py_Void();
26877 return resultobj;
26878 fail:
26879 return NULL;
26880 }
26881
26882
26883 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26884 PyObject *obj;
26885 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26886 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26887 return SWIG_Py_Void();
26888 }
26889
26890 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26891 return SWIG_Python_InitShadowInstance(args);
26892 }
26893
26894 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26895 PyObject *resultobj = 0;
26896 wxPyApp *result = 0 ;
26897
26898 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26899 {
26900 PyThreadState* __tstate = wxPyBeginAllowThreads();
26901 result = (wxPyApp *)new_wxPyApp();
26902 wxPyEndAllowThreads(__tstate);
26903 if (PyErr_Occurred()) SWIG_fail;
26904 }
26905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26906 return resultobj;
26907 fail:
26908 return NULL;
26909 }
26910
26911
26912 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26913 PyObject *resultobj = 0;
26914 wxPyApp *arg1 = (wxPyApp *) 0 ;
26915 void *argp1 = 0 ;
26916 int res1 = 0 ;
26917 PyObject *swig_obj[1] ;
26918
26919 if (!args) SWIG_fail;
26920 swig_obj[0] = args;
26921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26922 if (!SWIG_IsOK(res1)) {
26923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26924 }
26925 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26926 {
26927 PyThreadState* __tstate = wxPyBeginAllowThreads();
26928 delete arg1;
26929
26930 wxPyEndAllowThreads(__tstate);
26931 if (PyErr_Occurred()) SWIG_fail;
26932 }
26933 resultobj = SWIG_Py_Void();
26934 return resultobj;
26935 fail:
26936 return NULL;
26937 }
26938
26939
26940 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26941 PyObject *resultobj = 0;
26942 wxPyApp *arg1 = (wxPyApp *) 0 ;
26943 PyObject *arg2 = (PyObject *) 0 ;
26944 PyObject *arg3 = (PyObject *) 0 ;
26945 bool arg4 ;
26946 void *argp1 = 0 ;
26947 int res1 = 0 ;
26948 bool val4 ;
26949 int ecode4 = 0 ;
26950 PyObject * obj0 = 0 ;
26951 PyObject * obj1 = 0 ;
26952 PyObject * obj2 = 0 ;
26953 PyObject * obj3 = 0 ;
26954 char * kwnames[] = {
26955 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26956 };
26957
26958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26960 if (!SWIG_IsOK(res1)) {
26961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26962 }
26963 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26964 arg2 = obj1;
26965 arg3 = obj2;
26966 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26967 if (!SWIG_IsOK(ecode4)) {
26968 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26969 }
26970 arg4 = static_cast< bool >(val4);
26971 {
26972 PyThreadState* __tstate = wxPyBeginAllowThreads();
26973 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26974 wxPyEndAllowThreads(__tstate);
26975 if (PyErr_Occurred()) SWIG_fail;
26976 }
26977 resultobj = SWIG_Py_Void();
26978 return resultobj;
26979 fail:
26980 return NULL;
26981 }
26982
26983
26984 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26985 PyObject *resultobj = 0;
26986 wxPyApp *arg1 = (wxPyApp *) 0 ;
26987 wxString result;
26988 void *argp1 = 0 ;
26989 int res1 = 0 ;
26990 PyObject *swig_obj[1] ;
26991
26992 if (!args) SWIG_fail;
26993 swig_obj[0] = args;
26994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26995 if (!SWIG_IsOK(res1)) {
26996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26997 }
26998 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26999 {
27000 PyThreadState* __tstate = wxPyBeginAllowThreads();
27001 result = ((wxPyApp const *)arg1)->GetAppName();
27002 wxPyEndAllowThreads(__tstate);
27003 if (PyErr_Occurred()) SWIG_fail;
27004 }
27005 {
27006 #if wxUSE_UNICODE
27007 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27008 #else
27009 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27010 #endif
27011 }
27012 return resultobj;
27013 fail:
27014 return NULL;
27015 }
27016
27017
27018 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27019 PyObject *resultobj = 0;
27020 wxPyApp *arg1 = (wxPyApp *) 0 ;
27021 wxString *arg2 = 0 ;
27022 void *argp1 = 0 ;
27023 int res1 = 0 ;
27024 bool temp2 = false ;
27025 PyObject * obj0 = 0 ;
27026 PyObject * obj1 = 0 ;
27027 char * kwnames[] = {
27028 (char *) "self",(char *) "name", NULL
27029 };
27030
27031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27033 if (!SWIG_IsOK(res1)) {
27034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27035 }
27036 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27037 {
27038 arg2 = wxString_in_helper(obj1);
27039 if (arg2 == NULL) SWIG_fail;
27040 temp2 = true;
27041 }
27042 {
27043 PyThreadState* __tstate = wxPyBeginAllowThreads();
27044 (arg1)->SetAppName((wxString const &)*arg2);
27045 wxPyEndAllowThreads(__tstate);
27046 if (PyErr_Occurred()) SWIG_fail;
27047 }
27048 resultobj = SWIG_Py_Void();
27049 {
27050 if (temp2)
27051 delete arg2;
27052 }
27053 return resultobj;
27054 fail:
27055 {
27056 if (temp2)
27057 delete arg2;
27058 }
27059 return NULL;
27060 }
27061
27062
27063 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27064 PyObject *resultobj = 0;
27065 wxPyApp *arg1 = (wxPyApp *) 0 ;
27066 wxString result;
27067 void *argp1 = 0 ;
27068 int res1 = 0 ;
27069 PyObject *swig_obj[1] ;
27070
27071 if (!args) SWIG_fail;
27072 swig_obj[0] = args;
27073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27074 if (!SWIG_IsOK(res1)) {
27075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27076 }
27077 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27078 {
27079 PyThreadState* __tstate = wxPyBeginAllowThreads();
27080 result = ((wxPyApp const *)arg1)->GetClassName();
27081 wxPyEndAllowThreads(__tstate);
27082 if (PyErr_Occurred()) SWIG_fail;
27083 }
27084 {
27085 #if wxUSE_UNICODE
27086 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27087 #else
27088 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27089 #endif
27090 }
27091 return resultobj;
27092 fail:
27093 return NULL;
27094 }
27095
27096
27097 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27098 PyObject *resultobj = 0;
27099 wxPyApp *arg1 = (wxPyApp *) 0 ;
27100 wxString *arg2 = 0 ;
27101 void *argp1 = 0 ;
27102 int res1 = 0 ;
27103 bool temp2 = false ;
27104 PyObject * obj0 = 0 ;
27105 PyObject * obj1 = 0 ;
27106 char * kwnames[] = {
27107 (char *) "self",(char *) "name", NULL
27108 };
27109
27110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27112 if (!SWIG_IsOK(res1)) {
27113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27114 }
27115 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27116 {
27117 arg2 = wxString_in_helper(obj1);
27118 if (arg2 == NULL) SWIG_fail;
27119 temp2 = true;
27120 }
27121 {
27122 PyThreadState* __tstate = wxPyBeginAllowThreads();
27123 (arg1)->SetClassName((wxString const &)*arg2);
27124 wxPyEndAllowThreads(__tstate);
27125 if (PyErr_Occurred()) SWIG_fail;
27126 }
27127 resultobj = SWIG_Py_Void();
27128 {
27129 if (temp2)
27130 delete arg2;
27131 }
27132 return resultobj;
27133 fail:
27134 {
27135 if (temp2)
27136 delete arg2;
27137 }
27138 return NULL;
27139 }
27140
27141
27142 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27143 PyObject *resultobj = 0;
27144 wxPyApp *arg1 = (wxPyApp *) 0 ;
27145 wxString *result = 0 ;
27146 void *argp1 = 0 ;
27147 int res1 = 0 ;
27148 PyObject *swig_obj[1] ;
27149
27150 if (!args) SWIG_fail;
27151 swig_obj[0] = args;
27152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27153 if (!SWIG_IsOK(res1)) {
27154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27155 }
27156 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27157 {
27158 PyThreadState* __tstate = wxPyBeginAllowThreads();
27159 {
27160 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27161 result = (wxString *) &_result_ref;
27162 }
27163 wxPyEndAllowThreads(__tstate);
27164 if (PyErr_Occurred()) SWIG_fail;
27165 }
27166 {
27167 #if wxUSE_UNICODE
27168 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27169 #else
27170 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27171 #endif
27172 }
27173 return resultobj;
27174 fail:
27175 return NULL;
27176 }
27177
27178
27179 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27180 PyObject *resultobj = 0;
27181 wxPyApp *arg1 = (wxPyApp *) 0 ;
27182 wxString *arg2 = 0 ;
27183 void *argp1 = 0 ;
27184 int res1 = 0 ;
27185 bool temp2 = false ;
27186 PyObject * obj0 = 0 ;
27187 PyObject * obj1 = 0 ;
27188 char * kwnames[] = {
27189 (char *) "self",(char *) "name", NULL
27190 };
27191
27192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27194 if (!SWIG_IsOK(res1)) {
27195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27196 }
27197 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27198 {
27199 arg2 = wxString_in_helper(obj1);
27200 if (arg2 == NULL) SWIG_fail;
27201 temp2 = true;
27202 }
27203 {
27204 PyThreadState* __tstate = wxPyBeginAllowThreads();
27205 (arg1)->SetVendorName((wxString const &)*arg2);
27206 wxPyEndAllowThreads(__tstate);
27207 if (PyErr_Occurred()) SWIG_fail;
27208 }
27209 resultobj = SWIG_Py_Void();
27210 {
27211 if (temp2)
27212 delete arg2;
27213 }
27214 return resultobj;
27215 fail:
27216 {
27217 if (temp2)
27218 delete arg2;
27219 }
27220 return NULL;
27221 }
27222
27223
27224 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27225 PyObject *resultobj = 0;
27226 wxPyApp *arg1 = (wxPyApp *) 0 ;
27227 wxAppTraits *result = 0 ;
27228 void *argp1 = 0 ;
27229 int res1 = 0 ;
27230 PyObject *swig_obj[1] ;
27231
27232 if (!args) SWIG_fail;
27233 swig_obj[0] = args;
27234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27235 if (!SWIG_IsOK(res1)) {
27236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27237 }
27238 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27239 {
27240 PyThreadState* __tstate = wxPyBeginAllowThreads();
27241 result = (wxAppTraits *)(arg1)->GetTraits();
27242 wxPyEndAllowThreads(__tstate);
27243 if (PyErr_Occurred()) SWIG_fail;
27244 }
27245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27246 return resultobj;
27247 fail:
27248 return NULL;
27249 }
27250
27251
27252 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27253 PyObject *resultobj = 0;
27254 wxPyApp *arg1 = (wxPyApp *) 0 ;
27255 void *argp1 = 0 ;
27256 int res1 = 0 ;
27257 PyObject *swig_obj[1] ;
27258
27259 if (!args) SWIG_fail;
27260 swig_obj[0] = args;
27261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27262 if (!SWIG_IsOK(res1)) {
27263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27264 }
27265 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27266 {
27267 PyThreadState* __tstate = wxPyBeginAllowThreads();
27268 (arg1)->ProcessPendingEvents();
27269 wxPyEndAllowThreads(__tstate);
27270 if (PyErr_Occurred()) SWIG_fail;
27271 }
27272 resultobj = SWIG_Py_Void();
27273 return resultobj;
27274 fail:
27275 return NULL;
27276 }
27277
27278
27279 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27280 PyObject *resultobj = 0;
27281 wxPyApp *arg1 = (wxPyApp *) 0 ;
27282 bool arg2 = (bool) false ;
27283 bool result;
27284 void *argp1 = 0 ;
27285 int res1 = 0 ;
27286 bool val2 ;
27287 int ecode2 = 0 ;
27288 PyObject * obj0 = 0 ;
27289 PyObject * obj1 = 0 ;
27290 char * kwnames[] = {
27291 (char *) "self",(char *) "onlyIfNeeded", NULL
27292 };
27293
27294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27296 if (!SWIG_IsOK(res1)) {
27297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27298 }
27299 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27300 if (obj1) {
27301 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27302 if (!SWIG_IsOK(ecode2)) {
27303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27304 }
27305 arg2 = static_cast< bool >(val2);
27306 }
27307 {
27308 PyThreadState* __tstate = wxPyBeginAllowThreads();
27309 result = (bool)(arg1)->Yield(arg2);
27310 wxPyEndAllowThreads(__tstate);
27311 if (PyErr_Occurred()) SWIG_fail;
27312 }
27313 {
27314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27315 }
27316 return resultobj;
27317 fail:
27318 return NULL;
27319 }
27320
27321
27322 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27323 PyObject *resultobj = 0;
27324 wxPyApp *arg1 = (wxPyApp *) 0 ;
27325 void *argp1 = 0 ;
27326 int res1 = 0 ;
27327 PyObject *swig_obj[1] ;
27328
27329 if (!args) SWIG_fail;
27330 swig_obj[0] = args;
27331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27332 if (!SWIG_IsOK(res1)) {
27333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27334 }
27335 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27336 {
27337 PyThreadState* __tstate = wxPyBeginAllowThreads();
27338 (arg1)->WakeUpIdle();
27339 wxPyEndAllowThreads(__tstate);
27340 if (PyErr_Occurred()) SWIG_fail;
27341 }
27342 resultobj = SWIG_Py_Void();
27343 return resultobj;
27344 fail:
27345 return NULL;
27346 }
27347
27348
27349 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27350 PyObject *resultobj = 0;
27351 bool result;
27352
27353 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27354 {
27355 PyThreadState* __tstate = wxPyBeginAllowThreads();
27356 result = (bool)wxPyApp::IsMainLoopRunning();
27357 wxPyEndAllowThreads(__tstate);
27358 if (PyErr_Occurred()) SWIG_fail;
27359 }
27360 {
27361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27362 }
27363 return resultobj;
27364 fail:
27365 return NULL;
27366 }
27367
27368
27369 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27370 PyObject *resultobj = 0;
27371 wxPyApp *arg1 = (wxPyApp *) 0 ;
27372 int result;
27373 void *argp1 = 0 ;
27374 int res1 = 0 ;
27375 PyObject *swig_obj[1] ;
27376
27377 if (!args) SWIG_fail;
27378 swig_obj[0] = args;
27379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27380 if (!SWIG_IsOK(res1)) {
27381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27382 }
27383 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27384 {
27385 PyThreadState* __tstate = wxPyBeginAllowThreads();
27386 result = (int)(arg1)->MainLoop();
27387 wxPyEndAllowThreads(__tstate);
27388 if (PyErr_Occurred()) SWIG_fail;
27389 }
27390 resultobj = SWIG_From_int(static_cast< int >(result));
27391 return resultobj;
27392 fail:
27393 return NULL;
27394 }
27395
27396
27397 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27398 PyObject *resultobj = 0;
27399 wxPyApp *arg1 = (wxPyApp *) 0 ;
27400 void *argp1 = 0 ;
27401 int res1 = 0 ;
27402 PyObject *swig_obj[1] ;
27403
27404 if (!args) SWIG_fail;
27405 swig_obj[0] = args;
27406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27407 if (!SWIG_IsOK(res1)) {
27408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27409 }
27410 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27411 {
27412 PyThreadState* __tstate = wxPyBeginAllowThreads();
27413 (arg1)->Exit();
27414 wxPyEndAllowThreads(__tstate);
27415 if (PyErr_Occurred()) SWIG_fail;
27416 }
27417 resultobj = SWIG_Py_Void();
27418 return resultobj;
27419 fail:
27420 return NULL;
27421 }
27422
27423
27424 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27425 PyObject *resultobj = 0;
27426 wxPyApp *arg1 = (wxPyApp *) 0 ;
27427 void *argp1 = 0 ;
27428 int res1 = 0 ;
27429 PyObject *swig_obj[1] ;
27430
27431 if (!args) SWIG_fail;
27432 swig_obj[0] = args;
27433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27434 if (!SWIG_IsOK(res1)) {
27435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27436 }
27437 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27438 {
27439 PyThreadState* __tstate = wxPyBeginAllowThreads();
27440 (arg1)->ExitMainLoop();
27441 wxPyEndAllowThreads(__tstate);
27442 if (PyErr_Occurred()) SWIG_fail;
27443 }
27444 resultobj = SWIG_Py_Void();
27445 return resultobj;
27446 fail:
27447 return NULL;
27448 }
27449
27450
27451 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27452 PyObject *resultobj = 0;
27453 wxPyApp *arg1 = (wxPyApp *) 0 ;
27454 bool result;
27455 void *argp1 = 0 ;
27456 int res1 = 0 ;
27457 PyObject *swig_obj[1] ;
27458
27459 if (!args) SWIG_fail;
27460 swig_obj[0] = args;
27461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27462 if (!SWIG_IsOK(res1)) {
27463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27464 }
27465 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27466 {
27467 PyThreadState* __tstate = wxPyBeginAllowThreads();
27468 result = (bool)(arg1)->Pending();
27469 wxPyEndAllowThreads(__tstate);
27470 if (PyErr_Occurred()) SWIG_fail;
27471 }
27472 {
27473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27474 }
27475 return resultobj;
27476 fail:
27477 return NULL;
27478 }
27479
27480
27481 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27482 PyObject *resultobj = 0;
27483 wxPyApp *arg1 = (wxPyApp *) 0 ;
27484 bool result;
27485 void *argp1 = 0 ;
27486 int res1 = 0 ;
27487 PyObject *swig_obj[1] ;
27488
27489 if (!args) SWIG_fail;
27490 swig_obj[0] = args;
27491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27492 if (!SWIG_IsOK(res1)) {
27493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27494 }
27495 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27496 {
27497 PyThreadState* __tstate = wxPyBeginAllowThreads();
27498 result = (bool)(arg1)->Dispatch();
27499 wxPyEndAllowThreads(__tstate);
27500 if (PyErr_Occurred()) SWIG_fail;
27501 }
27502 {
27503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27504 }
27505 return resultobj;
27506 fail:
27507 return NULL;
27508 }
27509
27510
27511 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27512 PyObject *resultobj = 0;
27513 wxPyApp *arg1 = (wxPyApp *) 0 ;
27514 bool result;
27515 void *argp1 = 0 ;
27516 int res1 = 0 ;
27517 PyObject *swig_obj[1] ;
27518
27519 if (!args) SWIG_fail;
27520 swig_obj[0] = args;
27521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27522 if (!SWIG_IsOK(res1)) {
27523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27524 }
27525 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27526 {
27527 PyThreadState* __tstate = wxPyBeginAllowThreads();
27528 result = (bool)(arg1)->ProcessIdle();
27529 wxPyEndAllowThreads(__tstate);
27530 if (PyErr_Occurred()) SWIG_fail;
27531 }
27532 {
27533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27534 }
27535 return resultobj;
27536 fail:
27537 return NULL;
27538 }
27539
27540
27541 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27542 PyObject *resultobj = 0;
27543 wxPyApp *arg1 = (wxPyApp *) 0 ;
27544 wxWindow *arg2 = (wxWindow *) 0 ;
27545 wxIdleEvent *arg3 = 0 ;
27546 bool result;
27547 void *argp1 = 0 ;
27548 int res1 = 0 ;
27549 void *argp2 = 0 ;
27550 int res2 = 0 ;
27551 void *argp3 = 0 ;
27552 int res3 = 0 ;
27553 PyObject * obj0 = 0 ;
27554 PyObject * obj1 = 0 ;
27555 PyObject * obj2 = 0 ;
27556 char * kwnames[] = {
27557 (char *) "self",(char *) "win",(char *) "event", NULL
27558 };
27559
27560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27562 if (!SWIG_IsOK(res1)) {
27563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27564 }
27565 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27566 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27567 if (!SWIG_IsOK(res2)) {
27568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27569 }
27570 arg2 = reinterpret_cast< wxWindow * >(argp2);
27571 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27572 if (!SWIG_IsOK(res3)) {
27573 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27574 }
27575 if (!argp3) {
27576 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27577 }
27578 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27579 {
27580 PyThreadState* __tstate = wxPyBeginAllowThreads();
27581 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27582 wxPyEndAllowThreads(__tstate);
27583 if (PyErr_Occurred()) SWIG_fail;
27584 }
27585 {
27586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27587 }
27588 return resultobj;
27589 fail:
27590 return NULL;
27591 }
27592
27593
27594 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27595 PyObject *resultobj = 0;
27596 wxPyApp *arg1 = (wxPyApp *) 0 ;
27597 bool result;
27598 void *argp1 = 0 ;
27599 int res1 = 0 ;
27600 PyObject *swig_obj[1] ;
27601
27602 if (!args) SWIG_fail;
27603 swig_obj[0] = args;
27604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27605 if (!SWIG_IsOK(res1)) {
27606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27607 }
27608 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27609 {
27610 PyThreadState* __tstate = wxPyBeginAllowThreads();
27611 result = (bool)((wxPyApp const *)arg1)->IsActive();
27612 wxPyEndAllowThreads(__tstate);
27613 if (PyErr_Occurred()) SWIG_fail;
27614 }
27615 {
27616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27617 }
27618 return resultobj;
27619 fail:
27620 return NULL;
27621 }
27622
27623
27624 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27625 PyObject *resultobj = 0;
27626 wxPyApp *arg1 = (wxPyApp *) 0 ;
27627 wxWindow *arg2 = (wxWindow *) 0 ;
27628 void *argp1 = 0 ;
27629 int res1 = 0 ;
27630 void *argp2 = 0 ;
27631 int res2 = 0 ;
27632 PyObject * obj0 = 0 ;
27633 PyObject * obj1 = 0 ;
27634 char * kwnames[] = {
27635 (char *) "self",(char *) "win", NULL
27636 };
27637
27638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27640 if (!SWIG_IsOK(res1)) {
27641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27642 }
27643 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27644 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27645 if (!SWIG_IsOK(res2)) {
27646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27647 }
27648 arg2 = reinterpret_cast< wxWindow * >(argp2);
27649 {
27650 PyThreadState* __tstate = wxPyBeginAllowThreads();
27651 (arg1)->SetTopWindow(arg2);
27652 wxPyEndAllowThreads(__tstate);
27653 if (PyErr_Occurred()) SWIG_fail;
27654 }
27655 resultobj = SWIG_Py_Void();
27656 return resultobj;
27657 fail:
27658 return NULL;
27659 }
27660
27661
27662 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27663 PyObject *resultobj = 0;
27664 wxPyApp *arg1 = (wxPyApp *) 0 ;
27665 wxWindow *result = 0 ;
27666 void *argp1 = 0 ;
27667 int res1 = 0 ;
27668 PyObject *swig_obj[1] ;
27669
27670 if (!args) SWIG_fail;
27671 swig_obj[0] = args;
27672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27673 if (!SWIG_IsOK(res1)) {
27674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27675 }
27676 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27677 {
27678 PyThreadState* __tstate = wxPyBeginAllowThreads();
27679 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27680 wxPyEndAllowThreads(__tstate);
27681 if (PyErr_Occurred()) SWIG_fail;
27682 }
27683 {
27684 resultobj = wxPyMake_wxObject(result, (bool)0);
27685 }
27686 return resultobj;
27687 fail:
27688 return NULL;
27689 }
27690
27691
27692 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27693 PyObject *resultobj = 0;
27694 wxPyApp *arg1 = (wxPyApp *) 0 ;
27695 bool arg2 ;
27696 void *argp1 = 0 ;
27697 int res1 = 0 ;
27698 bool val2 ;
27699 int ecode2 = 0 ;
27700 PyObject * obj0 = 0 ;
27701 PyObject * obj1 = 0 ;
27702 char * kwnames[] = {
27703 (char *) "self",(char *) "flag", NULL
27704 };
27705
27706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27708 if (!SWIG_IsOK(res1)) {
27709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27710 }
27711 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27712 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27713 if (!SWIG_IsOK(ecode2)) {
27714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27715 }
27716 arg2 = static_cast< bool >(val2);
27717 {
27718 PyThreadState* __tstate = wxPyBeginAllowThreads();
27719 (arg1)->SetExitOnFrameDelete(arg2);
27720 wxPyEndAllowThreads(__tstate);
27721 if (PyErr_Occurred()) SWIG_fail;
27722 }
27723 resultobj = SWIG_Py_Void();
27724 return resultobj;
27725 fail:
27726 return NULL;
27727 }
27728
27729
27730 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27731 PyObject *resultobj = 0;
27732 wxPyApp *arg1 = (wxPyApp *) 0 ;
27733 bool result;
27734 void *argp1 = 0 ;
27735 int res1 = 0 ;
27736 PyObject *swig_obj[1] ;
27737
27738 if (!args) SWIG_fail;
27739 swig_obj[0] = args;
27740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27741 if (!SWIG_IsOK(res1)) {
27742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27743 }
27744 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27745 {
27746 PyThreadState* __tstate = wxPyBeginAllowThreads();
27747 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27748 wxPyEndAllowThreads(__tstate);
27749 if (PyErr_Occurred()) SWIG_fail;
27750 }
27751 {
27752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27753 }
27754 return resultobj;
27755 fail:
27756 return NULL;
27757 }
27758
27759
27760 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27761 PyObject *resultobj = 0;
27762 wxPyApp *arg1 = (wxPyApp *) 0 ;
27763 bool arg2 ;
27764 void *argp1 = 0 ;
27765 int res1 = 0 ;
27766 bool val2 ;
27767 int ecode2 = 0 ;
27768 PyObject * obj0 = 0 ;
27769 PyObject * obj1 = 0 ;
27770 char * kwnames[] = {
27771 (char *) "self",(char *) "flag", NULL
27772 };
27773
27774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27776 if (!SWIG_IsOK(res1)) {
27777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27778 }
27779 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27780 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27781 if (!SWIG_IsOK(ecode2)) {
27782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27783 }
27784 arg2 = static_cast< bool >(val2);
27785 {
27786 PyThreadState* __tstate = wxPyBeginAllowThreads();
27787 (arg1)->SetUseBestVisual(arg2);
27788 wxPyEndAllowThreads(__tstate);
27789 if (PyErr_Occurred()) SWIG_fail;
27790 }
27791 resultobj = SWIG_Py_Void();
27792 return resultobj;
27793 fail:
27794 return NULL;
27795 }
27796
27797
27798 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27799 PyObject *resultobj = 0;
27800 wxPyApp *arg1 = (wxPyApp *) 0 ;
27801 bool result;
27802 void *argp1 = 0 ;
27803 int res1 = 0 ;
27804 PyObject *swig_obj[1] ;
27805
27806 if (!args) SWIG_fail;
27807 swig_obj[0] = args;
27808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27809 if (!SWIG_IsOK(res1)) {
27810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27811 }
27812 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27813 {
27814 PyThreadState* __tstate = wxPyBeginAllowThreads();
27815 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27816 wxPyEndAllowThreads(__tstate);
27817 if (PyErr_Occurred()) SWIG_fail;
27818 }
27819 {
27820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27821 }
27822 return resultobj;
27823 fail:
27824 return NULL;
27825 }
27826
27827
27828 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27829 PyObject *resultobj = 0;
27830 wxPyApp *arg1 = (wxPyApp *) 0 ;
27831 int arg2 ;
27832 void *argp1 = 0 ;
27833 int res1 = 0 ;
27834 int val2 ;
27835 int ecode2 = 0 ;
27836 PyObject * obj0 = 0 ;
27837 PyObject * obj1 = 0 ;
27838 char * kwnames[] = {
27839 (char *) "self",(char *) "mode", NULL
27840 };
27841
27842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27844 if (!SWIG_IsOK(res1)) {
27845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27846 }
27847 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27848 ecode2 = SWIG_AsVal_int(obj1, &val2);
27849 if (!SWIG_IsOK(ecode2)) {
27850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27851 }
27852 arg2 = static_cast< int >(val2);
27853 {
27854 PyThreadState* __tstate = wxPyBeginAllowThreads();
27855 (arg1)->SetPrintMode(arg2);
27856 wxPyEndAllowThreads(__tstate);
27857 if (PyErr_Occurred()) SWIG_fail;
27858 }
27859 resultobj = SWIG_Py_Void();
27860 return resultobj;
27861 fail:
27862 return NULL;
27863 }
27864
27865
27866 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27867 PyObject *resultobj = 0;
27868 wxPyApp *arg1 = (wxPyApp *) 0 ;
27869 int result;
27870 void *argp1 = 0 ;
27871 int res1 = 0 ;
27872 PyObject *swig_obj[1] ;
27873
27874 if (!args) SWIG_fail;
27875 swig_obj[0] = args;
27876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27877 if (!SWIG_IsOK(res1)) {
27878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27879 }
27880 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27881 {
27882 PyThreadState* __tstate = wxPyBeginAllowThreads();
27883 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27884 wxPyEndAllowThreads(__tstate);
27885 if (PyErr_Occurred()) SWIG_fail;
27886 }
27887 resultobj = SWIG_From_int(static_cast< int >(result));
27888 return resultobj;
27889 fail:
27890 return NULL;
27891 }
27892
27893
27894 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27895 PyObject *resultobj = 0;
27896 wxPyApp *arg1 = (wxPyApp *) 0 ;
27897 int arg2 ;
27898 void *argp1 = 0 ;
27899 int res1 = 0 ;
27900 int val2 ;
27901 int ecode2 = 0 ;
27902 PyObject * obj0 = 0 ;
27903 PyObject * obj1 = 0 ;
27904 char * kwnames[] = {
27905 (char *) "self",(char *) "mode", NULL
27906 };
27907
27908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27910 if (!SWIG_IsOK(res1)) {
27911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27912 }
27913 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27914 ecode2 = SWIG_AsVal_int(obj1, &val2);
27915 if (!SWIG_IsOK(ecode2)) {
27916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27917 }
27918 arg2 = static_cast< int >(val2);
27919 {
27920 PyThreadState* __tstate = wxPyBeginAllowThreads();
27921 (arg1)->SetAssertMode(arg2);
27922 wxPyEndAllowThreads(__tstate);
27923 if (PyErr_Occurred()) SWIG_fail;
27924 }
27925 resultobj = SWIG_Py_Void();
27926 return resultobj;
27927 fail:
27928 return NULL;
27929 }
27930
27931
27932 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27933 PyObject *resultobj = 0;
27934 wxPyApp *arg1 = (wxPyApp *) 0 ;
27935 int result;
27936 void *argp1 = 0 ;
27937 int res1 = 0 ;
27938 PyObject *swig_obj[1] ;
27939
27940 if (!args) SWIG_fail;
27941 swig_obj[0] = args;
27942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27943 if (!SWIG_IsOK(res1)) {
27944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27945 }
27946 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27947 {
27948 PyThreadState* __tstate = wxPyBeginAllowThreads();
27949 result = (int)(arg1)->GetAssertMode();
27950 wxPyEndAllowThreads(__tstate);
27951 if (PyErr_Occurred()) SWIG_fail;
27952 }
27953 resultobj = SWIG_From_int(static_cast< int >(result));
27954 return resultobj;
27955 fail:
27956 return NULL;
27957 }
27958
27959
27960 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27961 PyObject *resultobj = 0;
27962 bool result;
27963
27964 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27965 {
27966 PyThreadState* __tstate = wxPyBeginAllowThreads();
27967 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27968 wxPyEndAllowThreads(__tstate);
27969 if (PyErr_Occurred()) SWIG_fail;
27970 }
27971 {
27972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27973 }
27974 return resultobj;
27975 fail:
27976 return NULL;
27977 }
27978
27979
27980 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27981 PyObject *resultobj = 0;
27982 long result;
27983
27984 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27985 {
27986 PyThreadState* __tstate = wxPyBeginAllowThreads();
27987 result = (long)wxPyApp::GetMacAboutMenuItemId();
27988 wxPyEndAllowThreads(__tstate);
27989 if (PyErr_Occurred()) SWIG_fail;
27990 }
27991 resultobj = SWIG_From_long(static_cast< long >(result));
27992 return resultobj;
27993 fail:
27994 return NULL;
27995 }
27996
27997
27998 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27999 PyObject *resultobj = 0;
28000 long result;
28001
28002 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28003 {
28004 PyThreadState* __tstate = wxPyBeginAllowThreads();
28005 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28006 wxPyEndAllowThreads(__tstate);
28007 if (PyErr_Occurred()) SWIG_fail;
28008 }
28009 resultobj = SWIG_From_long(static_cast< long >(result));
28010 return resultobj;
28011 fail:
28012 return NULL;
28013 }
28014
28015
28016 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28017 PyObject *resultobj = 0;
28018 long result;
28019
28020 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28021 {
28022 PyThreadState* __tstate = wxPyBeginAllowThreads();
28023 result = (long)wxPyApp::GetMacExitMenuItemId();
28024 wxPyEndAllowThreads(__tstate);
28025 if (PyErr_Occurred()) SWIG_fail;
28026 }
28027 resultobj = SWIG_From_long(static_cast< long >(result));
28028 return resultobj;
28029 fail:
28030 return NULL;
28031 }
28032
28033
28034 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28035 PyObject *resultobj = 0;
28036 wxString result;
28037
28038 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28039 {
28040 PyThreadState* __tstate = wxPyBeginAllowThreads();
28041 result = wxPyApp::GetMacHelpMenuTitleName();
28042 wxPyEndAllowThreads(__tstate);
28043 if (PyErr_Occurred()) SWIG_fail;
28044 }
28045 {
28046 #if wxUSE_UNICODE
28047 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28048 #else
28049 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28050 #endif
28051 }
28052 return resultobj;
28053 fail:
28054 return NULL;
28055 }
28056
28057
28058 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28059 PyObject *resultobj = 0;
28060 bool arg1 ;
28061 bool val1 ;
28062 int ecode1 = 0 ;
28063 PyObject * obj0 = 0 ;
28064 char * kwnames[] = {
28065 (char *) "val", NULL
28066 };
28067
28068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28069 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28070 if (!SWIG_IsOK(ecode1)) {
28071 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28072 }
28073 arg1 = static_cast< bool >(val1);
28074 {
28075 PyThreadState* __tstate = wxPyBeginAllowThreads();
28076 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28077 wxPyEndAllowThreads(__tstate);
28078 if (PyErr_Occurred()) SWIG_fail;
28079 }
28080 resultobj = SWIG_Py_Void();
28081 return resultobj;
28082 fail:
28083 return NULL;
28084 }
28085
28086
28087 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28088 PyObject *resultobj = 0;
28089 long arg1 ;
28090 long val1 ;
28091 int ecode1 = 0 ;
28092 PyObject * obj0 = 0 ;
28093 char * kwnames[] = {
28094 (char *) "val", NULL
28095 };
28096
28097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28098 ecode1 = SWIG_AsVal_long(obj0, &val1);
28099 if (!SWIG_IsOK(ecode1)) {
28100 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28101 }
28102 arg1 = static_cast< long >(val1);
28103 {
28104 PyThreadState* __tstate = wxPyBeginAllowThreads();
28105 wxPyApp::SetMacAboutMenuItemId(arg1);
28106 wxPyEndAllowThreads(__tstate);
28107 if (PyErr_Occurred()) SWIG_fail;
28108 }
28109 resultobj = SWIG_Py_Void();
28110 return resultobj;
28111 fail:
28112 return NULL;
28113 }
28114
28115
28116 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28117 PyObject *resultobj = 0;
28118 long arg1 ;
28119 long val1 ;
28120 int ecode1 = 0 ;
28121 PyObject * obj0 = 0 ;
28122 char * kwnames[] = {
28123 (char *) "val", NULL
28124 };
28125
28126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28127 ecode1 = SWIG_AsVal_long(obj0, &val1);
28128 if (!SWIG_IsOK(ecode1)) {
28129 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28130 }
28131 arg1 = static_cast< long >(val1);
28132 {
28133 PyThreadState* __tstate = wxPyBeginAllowThreads();
28134 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28135 wxPyEndAllowThreads(__tstate);
28136 if (PyErr_Occurred()) SWIG_fail;
28137 }
28138 resultobj = SWIG_Py_Void();
28139 return resultobj;
28140 fail:
28141 return NULL;
28142 }
28143
28144
28145 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28146 PyObject *resultobj = 0;
28147 long arg1 ;
28148 long val1 ;
28149 int ecode1 = 0 ;
28150 PyObject * obj0 = 0 ;
28151 char * kwnames[] = {
28152 (char *) "val", NULL
28153 };
28154
28155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28156 ecode1 = SWIG_AsVal_long(obj0, &val1);
28157 if (!SWIG_IsOK(ecode1)) {
28158 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28159 }
28160 arg1 = static_cast< long >(val1);
28161 {
28162 PyThreadState* __tstate = wxPyBeginAllowThreads();
28163 wxPyApp::SetMacExitMenuItemId(arg1);
28164 wxPyEndAllowThreads(__tstate);
28165 if (PyErr_Occurred()) SWIG_fail;
28166 }
28167 resultobj = SWIG_Py_Void();
28168 return resultobj;
28169 fail:
28170 return NULL;
28171 }
28172
28173
28174 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28175 PyObject *resultobj = 0;
28176 wxString *arg1 = 0 ;
28177 bool temp1 = false ;
28178 PyObject * obj0 = 0 ;
28179 char * kwnames[] = {
28180 (char *) "val", NULL
28181 };
28182
28183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28184 {
28185 arg1 = wxString_in_helper(obj0);
28186 if (arg1 == NULL) SWIG_fail;
28187 temp1 = true;
28188 }
28189 {
28190 PyThreadState* __tstate = wxPyBeginAllowThreads();
28191 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28192 wxPyEndAllowThreads(__tstate);
28193 if (PyErr_Occurred()) SWIG_fail;
28194 }
28195 resultobj = SWIG_Py_Void();
28196 {
28197 if (temp1)
28198 delete arg1;
28199 }
28200 return resultobj;
28201 fail:
28202 {
28203 if (temp1)
28204 delete arg1;
28205 }
28206 return NULL;
28207 }
28208
28209
28210 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28211 PyObject *resultobj = 0;
28212 wxPyApp *arg1 = (wxPyApp *) 0 ;
28213 void *argp1 = 0 ;
28214 int res1 = 0 ;
28215 PyObject *swig_obj[1] ;
28216
28217 if (!args) SWIG_fail;
28218 swig_obj[0] = args;
28219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28220 if (!SWIG_IsOK(res1)) {
28221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28222 }
28223 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28224 {
28225 PyThreadState* __tstate = wxPyBeginAllowThreads();
28226 (arg1)->_BootstrapApp();
28227 wxPyEndAllowThreads(__tstate);
28228 if (PyErr_Occurred()) SWIG_fail;
28229 }
28230 resultobj = SWIG_Py_Void();
28231 return resultobj;
28232 fail:
28233 return NULL;
28234 }
28235
28236
28237 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28238 PyObject *resultobj = 0;
28239 int result;
28240
28241 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28242 {
28243 PyThreadState* __tstate = wxPyBeginAllowThreads();
28244 result = (int)wxPyApp_GetComCtl32Version();
28245 wxPyEndAllowThreads(__tstate);
28246 if (PyErr_Occurred()) SWIG_fail;
28247 }
28248 resultobj = SWIG_From_int(static_cast< int >(result));
28249 return resultobj;
28250 fail:
28251 return NULL;
28252 }
28253
28254
28255 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28256 PyObject *obj;
28257 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28258 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28259 return SWIG_Py_Void();
28260 }
28261
28262 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28263 return SWIG_Python_InitShadowInstance(args);
28264 }
28265
28266 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28267 PyObject *resultobj = 0;
28268
28269 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28270 {
28271 PyThreadState* __tstate = wxPyBeginAllowThreads();
28272 wxExit();
28273 wxPyEndAllowThreads(__tstate);
28274 if (PyErr_Occurred()) SWIG_fail;
28275 }
28276 resultobj = SWIG_Py_Void();
28277 return resultobj;
28278 fail:
28279 return NULL;
28280 }
28281
28282
28283 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28284 PyObject *resultobj = 0;
28285 bool result;
28286
28287 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28288 {
28289 PyThreadState* __tstate = wxPyBeginAllowThreads();
28290 result = (bool)wxYield();
28291 wxPyEndAllowThreads(__tstate);
28292 if (PyErr_Occurred()) SWIG_fail;
28293 }
28294 {
28295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28296 }
28297 return resultobj;
28298 fail:
28299 return NULL;
28300 }
28301
28302
28303 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28304 PyObject *resultobj = 0;
28305 bool result;
28306
28307 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28308 {
28309 PyThreadState* __tstate = wxPyBeginAllowThreads();
28310 result = (bool)wxYieldIfNeeded();
28311 wxPyEndAllowThreads(__tstate);
28312 if (PyErr_Occurred()) SWIG_fail;
28313 }
28314 {
28315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28316 }
28317 return resultobj;
28318 fail:
28319 return NULL;
28320 }
28321
28322
28323 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28324 PyObject *resultobj = 0;
28325 wxWindow *arg1 = (wxWindow *) NULL ;
28326 bool arg2 = (bool) false ;
28327 bool result;
28328 void *argp1 = 0 ;
28329 int res1 = 0 ;
28330 bool val2 ;
28331 int ecode2 = 0 ;
28332 PyObject * obj0 = 0 ;
28333 PyObject * obj1 = 0 ;
28334 char * kwnames[] = {
28335 (char *) "win",(char *) "onlyIfNeeded", NULL
28336 };
28337
28338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28339 if (obj0) {
28340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28341 if (!SWIG_IsOK(res1)) {
28342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28343 }
28344 arg1 = reinterpret_cast< wxWindow * >(argp1);
28345 }
28346 if (obj1) {
28347 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28348 if (!SWIG_IsOK(ecode2)) {
28349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28350 }
28351 arg2 = static_cast< bool >(val2);
28352 }
28353 {
28354 PyThreadState* __tstate = wxPyBeginAllowThreads();
28355 result = (bool)wxSafeYield(arg1,arg2);
28356 wxPyEndAllowThreads(__tstate);
28357 if (PyErr_Occurred()) SWIG_fail;
28358 }
28359 {
28360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28361 }
28362 return resultobj;
28363 fail:
28364 return NULL;
28365 }
28366
28367
28368 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28369 PyObject *resultobj = 0;
28370
28371 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28372 {
28373 PyThreadState* __tstate = wxPyBeginAllowThreads();
28374 wxWakeUpIdle();
28375 wxPyEndAllowThreads(__tstate);
28376 if (PyErr_Occurred()) SWIG_fail;
28377 }
28378 resultobj = SWIG_Py_Void();
28379 return resultobj;
28380 fail:
28381 return NULL;
28382 }
28383
28384
28385 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28386 PyObject *resultobj = 0;
28387 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28388 wxEvent *arg2 = 0 ;
28389 void *argp1 = 0 ;
28390 int res1 = 0 ;
28391 void *argp2 = 0 ;
28392 int res2 = 0 ;
28393 PyObject * obj0 = 0 ;
28394 PyObject * obj1 = 0 ;
28395 char * kwnames[] = {
28396 (char *) "dest",(char *) "event", NULL
28397 };
28398
28399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28401 if (!SWIG_IsOK(res1)) {
28402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28403 }
28404 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28405 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28406 if (!SWIG_IsOK(res2)) {
28407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28408 }
28409 if (!argp2) {
28410 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28411 }
28412 arg2 = reinterpret_cast< wxEvent * >(argp2);
28413 {
28414 PyThreadState* __tstate = wxPyBeginAllowThreads();
28415 wxPostEvent(arg1,*arg2);
28416 wxPyEndAllowThreads(__tstate);
28417 if (PyErr_Occurred()) SWIG_fail;
28418 }
28419 resultobj = SWIG_Py_Void();
28420 return resultobj;
28421 fail:
28422 return NULL;
28423 }
28424
28425
28426 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28427 PyObject *resultobj = 0;
28428
28429 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28430 {
28431 PyThreadState* __tstate = wxPyBeginAllowThreads();
28432 wxApp_CleanUp();
28433 wxPyEndAllowThreads(__tstate);
28434 if (PyErr_Occurred()) SWIG_fail;
28435 }
28436 resultobj = SWIG_Py_Void();
28437 return resultobj;
28438 fail:
28439 return NULL;
28440 }
28441
28442
28443 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28444 PyObject *resultobj = 0;
28445 wxPyApp *result = 0 ;
28446
28447 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28448 {
28449 PyThreadState* __tstate = wxPyBeginAllowThreads();
28450 result = (wxPyApp *)wxPyGetApp();
28451 wxPyEndAllowThreads(__tstate);
28452 if (PyErr_Occurred()) SWIG_fail;
28453 }
28454 {
28455 resultobj = wxPyMake_wxObject(result, 0);
28456 }
28457 return resultobj;
28458 fail:
28459 return NULL;
28460 }
28461
28462
28463 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28464 PyObject *resultobj = 0;
28465 char *arg1 = (char *) 0 ;
28466 int res1 ;
28467 char *buf1 = 0 ;
28468 int alloc1 = 0 ;
28469 PyObject * obj0 = 0 ;
28470 char * kwnames[] = {
28471 (char *) "encoding", NULL
28472 };
28473
28474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28475 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28476 if (!SWIG_IsOK(res1)) {
28477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28478 }
28479 arg1 = buf1;
28480 {
28481 PyThreadState* __tstate = wxPyBeginAllowThreads();
28482 wxSetDefaultPyEncoding((char const *)arg1);
28483 wxPyEndAllowThreads(__tstate);
28484 if (PyErr_Occurred()) SWIG_fail;
28485 }
28486 resultobj = SWIG_Py_Void();
28487 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28488 return resultobj;
28489 fail:
28490 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28491 return NULL;
28492 }
28493
28494
28495 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28496 PyObject *resultobj = 0;
28497 char *result = 0 ;
28498
28499 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28500 {
28501 PyThreadState* __tstate = wxPyBeginAllowThreads();
28502 result = (char *)wxGetDefaultPyEncoding();
28503 wxPyEndAllowThreads(__tstate);
28504 if (PyErr_Occurred()) SWIG_fail;
28505 }
28506 resultobj = SWIG_FromCharPtr(result);
28507 return resultobj;
28508 fail:
28509 return NULL;
28510 }
28511
28512
28513 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28514 PyObject *resultobj = 0;
28515 wxEventLoop *result = 0 ;
28516
28517 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28518 {
28519 PyThreadState* __tstate = wxPyBeginAllowThreads();
28520 result = (wxEventLoop *)new wxEventLoop();
28521 wxPyEndAllowThreads(__tstate);
28522 if (PyErr_Occurred()) SWIG_fail;
28523 }
28524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28525 return resultobj;
28526 fail:
28527 return NULL;
28528 }
28529
28530
28531 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28532 PyObject *resultobj = 0;
28533 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28534 void *argp1 = 0 ;
28535 int res1 = 0 ;
28536 PyObject *swig_obj[1] ;
28537
28538 if (!args) SWIG_fail;
28539 swig_obj[0] = args;
28540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28541 if (!SWIG_IsOK(res1)) {
28542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28543 }
28544 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28545 {
28546 PyThreadState* __tstate = wxPyBeginAllowThreads();
28547 delete arg1;
28548
28549 wxPyEndAllowThreads(__tstate);
28550 if (PyErr_Occurred()) SWIG_fail;
28551 }
28552 resultobj = SWIG_Py_Void();
28553 return resultobj;
28554 fail:
28555 return NULL;
28556 }
28557
28558
28559 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28560 PyObject *resultobj = 0;
28561 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28562 int result;
28563 void *argp1 = 0 ;
28564 int res1 = 0 ;
28565 PyObject *swig_obj[1] ;
28566
28567 if (!args) SWIG_fail;
28568 swig_obj[0] = args;
28569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28570 if (!SWIG_IsOK(res1)) {
28571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28572 }
28573 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28574 {
28575 PyThreadState* __tstate = wxPyBeginAllowThreads();
28576 result = (int)(arg1)->Run();
28577 wxPyEndAllowThreads(__tstate);
28578 if (PyErr_Occurred()) SWIG_fail;
28579 }
28580 resultobj = SWIG_From_int(static_cast< int >(result));
28581 return resultobj;
28582 fail:
28583 return NULL;
28584 }
28585
28586
28587 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28588 PyObject *resultobj = 0;
28589 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28590 int arg2 = (int) 0 ;
28591 void *argp1 = 0 ;
28592 int res1 = 0 ;
28593 int val2 ;
28594 int ecode2 = 0 ;
28595 PyObject * obj0 = 0 ;
28596 PyObject * obj1 = 0 ;
28597 char * kwnames[] = {
28598 (char *) "self",(char *) "rc", NULL
28599 };
28600
28601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28603 if (!SWIG_IsOK(res1)) {
28604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28605 }
28606 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28607 if (obj1) {
28608 ecode2 = SWIG_AsVal_int(obj1, &val2);
28609 if (!SWIG_IsOK(ecode2)) {
28610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28611 }
28612 arg2 = static_cast< int >(val2);
28613 }
28614 {
28615 PyThreadState* __tstate = wxPyBeginAllowThreads();
28616 (arg1)->Exit(arg2);
28617 wxPyEndAllowThreads(__tstate);
28618 if (PyErr_Occurred()) SWIG_fail;
28619 }
28620 resultobj = SWIG_Py_Void();
28621 return resultobj;
28622 fail:
28623 return NULL;
28624 }
28625
28626
28627 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28628 PyObject *resultobj = 0;
28629 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28630 bool result;
28631 void *argp1 = 0 ;
28632 int res1 = 0 ;
28633 PyObject *swig_obj[1] ;
28634
28635 if (!args) SWIG_fail;
28636 swig_obj[0] = args;
28637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28638 if (!SWIG_IsOK(res1)) {
28639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28640 }
28641 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28642 {
28643 PyThreadState* __tstate = wxPyBeginAllowThreads();
28644 result = (bool)((wxEventLoop const *)arg1)->Pending();
28645 wxPyEndAllowThreads(__tstate);
28646 if (PyErr_Occurred()) SWIG_fail;
28647 }
28648 {
28649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28650 }
28651 return resultobj;
28652 fail:
28653 return NULL;
28654 }
28655
28656
28657 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28658 PyObject *resultobj = 0;
28659 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28660 bool result;
28661 void *argp1 = 0 ;
28662 int res1 = 0 ;
28663 PyObject *swig_obj[1] ;
28664
28665 if (!args) SWIG_fail;
28666 swig_obj[0] = args;
28667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28668 if (!SWIG_IsOK(res1)) {
28669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28670 }
28671 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28672 {
28673 PyThreadState* __tstate = wxPyBeginAllowThreads();
28674 result = (bool)(arg1)->Dispatch();
28675 wxPyEndAllowThreads(__tstate);
28676 if (PyErr_Occurred()) SWIG_fail;
28677 }
28678 {
28679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28680 }
28681 return resultobj;
28682 fail:
28683 return NULL;
28684 }
28685
28686
28687 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28688 PyObject *resultobj = 0;
28689 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28690 bool result;
28691 void *argp1 = 0 ;
28692 int res1 = 0 ;
28693 PyObject *swig_obj[1] ;
28694
28695 if (!args) SWIG_fail;
28696 swig_obj[0] = args;
28697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28698 if (!SWIG_IsOK(res1)) {
28699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28700 }
28701 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28702 {
28703 PyThreadState* __tstate = wxPyBeginAllowThreads();
28704 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28705 wxPyEndAllowThreads(__tstate);
28706 if (PyErr_Occurred()) SWIG_fail;
28707 }
28708 {
28709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28710 }
28711 return resultobj;
28712 fail:
28713 return NULL;
28714 }
28715
28716
28717 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28718 PyObject *resultobj = 0;
28719 wxEventLoop *result = 0 ;
28720
28721 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28722 {
28723 PyThreadState* __tstate = wxPyBeginAllowThreads();
28724 result = (wxEventLoop *)wxEventLoop::GetActive();
28725 wxPyEndAllowThreads(__tstate);
28726 if (PyErr_Occurred()) SWIG_fail;
28727 }
28728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28729 return resultobj;
28730 fail:
28731 return NULL;
28732 }
28733
28734
28735 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28736 PyObject *resultobj = 0;
28737 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28738 void *argp1 = 0 ;
28739 int res1 = 0 ;
28740 PyObject * obj0 = 0 ;
28741 char * kwnames[] = {
28742 (char *) "loop", NULL
28743 };
28744
28745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28747 if (!SWIG_IsOK(res1)) {
28748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28749 }
28750 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28751 {
28752 PyThreadState* __tstate = wxPyBeginAllowThreads();
28753 wxEventLoop::SetActive(arg1);
28754 wxPyEndAllowThreads(__tstate);
28755 if (PyErr_Occurred()) SWIG_fail;
28756 }
28757 resultobj = SWIG_Py_Void();
28758 return resultobj;
28759 fail:
28760 return NULL;
28761 }
28762
28763
28764 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28765 PyObject *obj;
28766 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28767 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28768 return SWIG_Py_Void();
28769 }
28770
28771 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28772 return SWIG_Python_InitShadowInstance(args);
28773 }
28774
28775 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28776 PyObject *resultobj = 0;
28777 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28778 wxEventLoopActivator *result = 0 ;
28779 void *argp1 = 0 ;
28780 int res1 = 0 ;
28781 PyObject * obj0 = 0 ;
28782 char * kwnames[] = {
28783 (char *) "evtLoop", NULL
28784 };
28785
28786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28788 if (!SWIG_IsOK(res1)) {
28789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28790 }
28791 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28792 {
28793 PyThreadState* __tstate = wxPyBeginAllowThreads();
28794 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28795 wxPyEndAllowThreads(__tstate);
28796 if (PyErr_Occurred()) SWIG_fail;
28797 }
28798 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28799 return resultobj;
28800 fail:
28801 return NULL;
28802 }
28803
28804
28805 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28806 PyObject *resultobj = 0;
28807 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28808 void *argp1 = 0 ;
28809 int res1 = 0 ;
28810 PyObject *swig_obj[1] ;
28811
28812 if (!args) SWIG_fail;
28813 swig_obj[0] = args;
28814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28815 if (!SWIG_IsOK(res1)) {
28816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28817 }
28818 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28819 {
28820 PyThreadState* __tstate = wxPyBeginAllowThreads();
28821 delete arg1;
28822
28823 wxPyEndAllowThreads(__tstate);
28824 if (PyErr_Occurred()) SWIG_fail;
28825 }
28826 resultobj = SWIG_Py_Void();
28827 return resultobj;
28828 fail:
28829 return NULL;
28830 }
28831
28832
28833 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28834 PyObject *obj;
28835 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28836 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28837 return SWIG_Py_Void();
28838 }
28839
28840 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28841 return SWIG_Python_InitShadowInstance(args);
28842 }
28843
28844 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28845 PyObject *resultobj = 0;
28846 int arg1 = (int) 0 ;
28847 int arg2 = (int) 0 ;
28848 int arg3 = (int) 0 ;
28849 wxAcceleratorEntry *result = 0 ;
28850 int val1 ;
28851 int ecode1 = 0 ;
28852 int val2 ;
28853 int ecode2 = 0 ;
28854 int val3 ;
28855 int ecode3 = 0 ;
28856 PyObject * obj0 = 0 ;
28857 PyObject * obj1 = 0 ;
28858 PyObject * obj2 = 0 ;
28859 char * kwnames[] = {
28860 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28861 };
28862
28863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28864 if (obj0) {
28865 ecode1 = SWIG_AsVal_int(obj0, &val1);
28866 if (!SWIG_IsOK(ecode1)) {
28867 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28868 }
28869 arg1 = static_cast< int >(val1);
28870 }
28871 if (obj1) {
28872 ecode2 = SWIG_AsVal_int(obj1, &val2);
28873 if (!SWIG_IsOK(ecode2)) {
28874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28875 }
28876 arg2 = static_cast< int >(val2);
28877 }
28878 if (obj2) {
28879 ecode3 = SWIG_AsVal_int(obj2, &val3);
28880 if (!SWIG_IsOK(ecode3)) {
28881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28882 }
28883 arg3 = static_cast< int >(val3);
28884 }
28885 {
28886 PyThreadState* __tstate = wxPyBeginAllowThreads();
28887 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28888 wxPyEndAllowThreads(__tstate);
28889 if (PyErr_Occurred()) SWIG_fail;
28890 }
28891 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28892 return resultobj;
28893 fail:
28894 return NULL;
28895 }
28896
28897
28898 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28899 PyObject *resultobj = 0;
28900 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28901 void *argp1 = 0 ;
28902 int res1 = 0 ;
28903 PyObject *swig_obj[1] ;
28904
28905 if (!args) SWIG_fail;
28906 swig_obj[0] = args;
28907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28908 if (!SWIG_IsOK(res1)) {
28909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28910 }
28911 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28912 {
28913 PyThreadState* __tstate = wxPyBeginAllowThreads();
28914 delete arg1;
28915
28916 wxPyEndAllowThreads(__tstate);
28917 if (PyErr_Occurred()) SWIG_fail;
28918 }
28919 resultobj = SWIG_Py_Void();
28920 return resultobj;
28921 fail:
28922 return NULL;
28923 }
28924
28925
28926 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28927 PyObject *resultobj = 0;
28928 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28929 int arg2 ;
28930 int arg3 ;
28931 int arg4 ;
28932 void *argp1 = 0 ;
28933 int res1 = 0 ;
28934 int val2 ;
28935 int ecode2 = 0 ;
28936 int val3 ;
28937 int ecode3 = 0 ;
28938 int val4 ;
28939 int ecode4 = 0 ;
28940 PyObject * obj0 = 0 ;
28941 PyObject * obj1 = 0 ;
28942 PyObject * obj2 = 0 ;
28943 PyObject * obj3 = 0 ;
28944 char * kwnames[] = {
28945 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28946 };
28947
28948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28950 if (!SWIG_IsOK(res1)) {
28951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28952 }
28953 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28954 ecode2 = SWIG_AsVal_int(obj1, &val2);
28955 if (!SWIG_IsOK(ecode2)) {
28956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28957 }
28958 arg2 = static_cast< int >(val2);
28959 ecode3 = SWIG_AsVal_int(obj2, &val3);
28960 if (!SWIG_IsOK(ecode3)) {
28961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28962 }
28963 arg3 = static_cast< int >(val3);
28964 ecode4 = SWIG_AsVal_int(obj3, &val4);
28965 if (!SWIG_IsOK(ecode4)) {
28966 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28967 }
28968 arg4 = static_cast< int >(val4);
28969 {
28970 PyThreadState* __tstate = wxPyBeginAllowThreads();
28971 (arg1)->Set(arg2,arg3,arg4);
28972 wxPyEndAllowThreads(__tstate);
28973 if (PyErr_Occurred()) SWIG_fail;
28974 }
28975 resultobj = SWIG_Py_Void();
28976 return resultobj;
28977 fail:
28978 return NULL;
28979 }
28980
28981
28982 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28983 PyObject *resultobj = 0;
28984 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28985 int result;
28986 void *argp1 = 0 ;
28987 int res1 = 0 ;
28988 PyObject *swig_obj[1] ;
28989
28990 if (!args) SWIG_fail;
28991 swig_obj[0] = args;
28992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28993 if (!SWIG_IsOK(res1)) {
28994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28995 }
28996 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28997 {
28998 PyThreadState* __tstate = wxPyBeginAllowThreads();
28999 result = (int)(arg1)->GetFlags();
29000 wxPyEndAllowThreads(__tstate);
29001 if (PyErr_Occurred()) SWIG_fail;
29002 }
29003 resultobj = SWIG_From_int(static_cast< int >(result));
29004 return resultobj;
29005 fail:
29006 return NULL;
29007 }
29008
29009
29010 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29011 PyObject *resultobj = 0;
29012 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29013 int result;
29014 void *argp1 = 0 ;
29015 int res1 = 0 ;
29016 PyObject *swig_obj[1] ;
29017
29018 if (!args) SWIG_fail;
29019 swig_obj[0] = args;
29020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29021 if (!SWIG_IsOK(res1)) {
29022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29023 }
29024 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29025 {
29026 PyThreadState* __tstate = wxPyBeginAllowThreads();
29027 result = (int)(arg1)->GetKeyCode();
29028 wxPyEndAllowThreads(__tstate);
29029 if (PyErr_Occurred()) SWIG_fail;
29030 }
29031 resultobj = SWIG_From_int(static_cast< int >(result));
29032 return resultobj;
29033 fail:
29034 return NULL;
29035 }
29036
29037
29038 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29039 PyObject *resultobj = 0;
29040 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29041 int result;
29042 void *argp1 = 0 ;
29043 int res1 = 0 ;
29044 PyObject *swig_obj[1] ;
29045
29046 if (!args) SWIG_fail;
29047 swig_obj[0] = args;
29048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29049 if (!SWIG_IsOK(res1)) {
29050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29051 }
29052 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29053 {
29054 PyThreadState* __tstate = wxPyBeginAllowThreads();
29055 result = (int)(arg1)->GetCommand();
29056 wxPyEndAllowThreads(__tstate);
29057 if (PyErr_Occurred()) SWIG_fail;
29058 }
29059 resultobj = SWIG_From_int(static_cast< int >(result));
29060 return resultobj;
29061 fail:
29062 return NULL;
29063 }
29064
29065
29066 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29067 PyObject *obj;
29068 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29069 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29070 return SWIG_Py_Void();
29071 }
29072
29073 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29074 return SWIG_Python_InitShadowInstance(args);
29075 }
29076
29077 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29078 PyObject *resultobj = 0;
29079 int arg1 ;
29080 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29081 wxAcceleratorTable *result = 0 ;
29082 PyObject * obj0 = 0 ;
29083 char * kwnames[] = {
29084 (char *) "n", NULL
29085 };
29086
29087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29088 {
29089 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29090 if (arg2) arg1 = PyList_Size(obj0);
29091 else arg1 = 0;
29092 }
29093 {
29094 PyThreadState* __tstate = wxPyBeginAllowThreads();
29095 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29096 wxPyEndAllowThreads(__tstate);
29097 if (PyErr_Occurred()) SWIG_fail;
29098 }
29099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29100 return resultobj;
29101 fail:
29102 return NULL;
29103 }
29104
29105
29106 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29107 PyObject *resultobj = 0;
29108 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29109 void *argp1 = 0 ;
29110 int res1 = 0 ;
29111 PyObject *swig_obj[1] ;
29112
29113 if (!args) SWIG_fail;
29114 swig_obj[0] = args;
29115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29116 if (!SWIG_IsOK(res1)) {
29117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29118 }
29119 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29120 {
29121 PyThreadState* __tstate = wxPyBeginAllowThreads();
29122 delete arg1;
29123
29124 wxPyEndAllowThreads(__tstate);
29125 if (PyErr_Occurred()) SWIG_fail;
29126 }
29127 resultobj = SWIG_Py_Void();
29128 return resultobj;
29129 fail:
29130 return NULL;
29131 }
29132
29133
29134 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29135 PyObject *resultobj = 0;
29136 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29137 bool result;
29138 void *argp1 = 0 ;
29139 int res1 = 0 ;
29140 PyObject *swig_obj[1] ;
29141
29142 if (!args) SWIG_fail;
29143 swig_obj[0] = args;
29144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29145 if (!SWIG_IsOK(res1)) {
29146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29147 }
29148 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29149 {
29150 PyThreadState* __tstate = wxPyBeginAllowThreads();
29151 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29152 wxPyEndAllowThreads(__tstate);
29153 if (PyErr_Occurred()) SWIG_fail;
29154 }
29155 {
29156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29157 }
29158 return resultobj;
29159 fail:
29160 return NULL;
29161 }
29162
29163
29164 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29165 PyObject *obj;
29166 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29167 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29168 return SWIG_Py_Void();
29169 }
29170
29171 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29172 return SWIG_Python_InitShadowInstance(args);
29173 }
29174
29175 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29176 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29177 return 1;
29178 }
29179
29180
29181 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29182 PyObject *pyobj = 0;
29183
29184 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29185 return pyobj;
29186 }
29187
29188
29189 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29190 PyObject *resultobj = 0;
29191 wxString *arg1 = 0 ;
29192 wxAcceleratorEntry *result = 0 ;
29193 bool temp1 = false ;
29194 PyObject * obj0 = 0 ;
29195 char * kwnames[] = {
29196 (char *) "label", NULL
29197 };
29198
29199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29200 {
29201 arg1 = wxString_in_helper(obj0);
29202 if (arg1 == NULL) SWIG_fail;
29203 temp1 = true;
29204 }
29205 {
29206 PyThreadState* __tstate = wxPyBeginAllowThreads();
29207 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29208 wxPyEndAllowThreads(__tstate);
29209 if (PyErr_Occurred()) SWIG_fail;
29210 }
29211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29212 {
29213 if (temp1)
29214 delete arg1;
29215 }
29216 return resultobj;
29217 fail:
29218 {
29219 if (temp1)
29220 delete arg1;
29221 }
29222 return NULL;
29223 }
29224
29225
29226 SWIGINTERN int PanelNameStr_set(PyObject *) {
29227 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29228 return 1;
29229 }
29230
29231
29232 SWIGINTERN PyObject *PanelNameStr_get(void) {
29233 PyObject *pyobj = 0;
29234
29235 {
29236 #if wxUSE_UNICODE
29237 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29238 #else
29239 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29240 #endif
29241 }
29242 return pyobj;
29243 }
29244
29245
29246 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29247 PyObject *resultobj = 0;
29248 wxVisualAttributes *result = 0 ;
29249
29250 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29251 {
29252 PyThreadState* __tstate = wxPyBeginAllowThreads();
29253 result = (wxVisualAttributes *)new_wxVisualAttributes();
29254 wxPyEndAllowThreads(__tstate);
29255 if (PyErr_Occurred()) SWIG_fail;
29256 }
29257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29258 return resultobj;
29259 fail:
29260 return NULL;
29261 }
29262
29263
29264 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29265 PyObject *resultobj = 0;
29266 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29267 void *argp1 = 0 ;
29268 int res1 = 0 ;
29269 PyObject *swig_obj[1] ;
29270
29271 if (!args) SWIG_fail;
29272 swig_obj[0] = args;
29273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29274 if (!SWIG_IsOK(res1)) {
29275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29276 }
29277 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29278 {
29279 PyThreadState* __tstate = wxPyBeginAllowThreads();
29280 delete_wxVisualAttributes(arg1);
29281
29282 wxPyEndAllowThreads(__tstate);
29283 if (PyErr_Occurred()) SWIG_fail;
29284 }
29285 resultobj = SWIG_Py_Void();
29286 return resultobj;
29287 fail:
29288 return NULL;
29289 }
29290
29291
29292 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29293 PyObject *resultobj = 0;
29294 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29295 wxFont *arg2 = (wxFont *) 0 ;
29296 void *argp1 = 0 ;
29297 int res1 = 0 ;
29298 void *argp2 = 0 ;
29299 int res2 = 0 ;
29300 PyObject *swig_obj[2] ;
29301
29302 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29304 if (!SWIG_IsOK(res1)) {
29305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29306 }
29307 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29308 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29309 if (!SWIG_IsOK(res2)) {
29310 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29311 }
29312 arg2 = reinterpret_cast< wxFont * >(argp2);
29313 if (arg1) (arg1)->font = *arg2;
29314
29315 resultobj = SWIG_Py_Void();
29316 return resultobj;
29317 fail:
29318 return NULL;
29319 }
29320
29321
29322 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29323 PyObject *resultobj = 0;
29324 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29325 wxFont *result = 0 ;
29326 void *argp1 = 0 ;
29327 int res1 = 0 ;
29328 PyObject *swig_obj[1] ;
29329
29330 if (!args) SWIG_fail;
29331 swig_obj[0] = args;
29332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29333 if (!SWIG_IsOK(res1)) {
29334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29335 }
29336 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29337 result = (wxFont *)& ((arg1)->font);
29338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29339 return resultobj;
29340 fail:
29341 return NULL;
29342 }
29343
29344
29345 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29346 PyObject *resultobj = 0;
29347 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29348 wxColour *arg2 = (wxColour *) 0 ;
29349 void *argp1 = 0 ;
29350 int res1 = 0 ;
29351 void *argp2 = 0 ;
29352 int res2 = 0 ;
29353 PyObject *swig_obj[2] ;
29354
29355 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29357 if (!SWIG_IsOK(res1)) {
29358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29359 }
29360 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29361 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29362 if (!SWIG_IsOK(res2)) {
29363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29364 }
29365 arg2 = reinterpret_cast< wxColour * >(argp2);
29366 if (arg1) (arg1)->colFg = *arg2;
29367
29368 resultobj = SWIG_Py_Void();
29369 return resultobj;
29370 fail:
29371 return NULL;
29372 }
29373
29374
29375 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29376 PyObject *resultobj = 0;
29377 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29378 wxColour *result = 0 ;
29379 void *argp1 = 0 ;
29380 int res1 = 0 ;
29381 PyObject *swig_obj[1] ;
29382
29383 if (!args) SWIG_fail;
29384 swig_obj[0] = args;
29385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29386 if (!SWIG_IsOK(res1)) {
29387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29388 }
29389 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29390 result = (wxColour *)& ((arg1)->colFg);
29391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29392 return resultobj;
29393 fail:
29394 return NULL;
29395 }
29396
29397
29398 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29399 PyObject *resultobj = 0;
29400 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29401 wxColour *arg2 = (wxColour *) 0 ;
29402 void *argp1 = 0 ;
29403 int res1 = 0 ;
29404 void *argp2 = 0 ;
29405 int res2 = 0 ;
29406 PyObject *swig_obj[2] ;
29407
29408 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29410 if (!SWIG_IsOK(res1)) {
29411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29412 }
29413 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29414 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29415 if (!SWIG_IsOK(res2)) {
29416 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29417 }
29418 arg2 = reinterpret_cast< wxColour * >(argp2);
29419 if (arg1) (arg1)->colBg = *arg2;
29420
29421 resultobj = SWIG_Py_Void();
29422 return resultobj;
29423 fail:
29424 return NULL;
29425 }
29426
29427
29428 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29429 PyObject *resultobj = 0;
29430 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29431 wxColour *result = 0 ;
29432 void *argp1 = 0 ;
29433 int res1 = 0 ;
29434 PyObject *swig_obj[1] ;
29435
29436 if (!args) SWIG_fail;
29437 swig_obj[0] = args;
29438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29439 if (!SWIG_IsOK(res1)) {
29440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29441 }
29442 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29443 result = (wxColour *)& ((arg1)->colBg);
29444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29445 return resultobj;
29446 fail:
29447 return NULL;
29448 }
29449
29450
29451 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29452 PyObject *obj;
29453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29454 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29455 return SWIG_Py_Void();
29456 }
29457
29458 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29459 return SWIG_Python_InitShadowInstance(args);
29460 }
29461
29462 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29463 PyObject *resultobj = 0;
29464 wxWindow *arg1 = (wxWindow *) 0 ;
29465 int arg2 = (int) (int)-1 ;
29466 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29467 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29468 wxSize const &arg4_defvalue = wxDefaultSize ;
29469 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29470 long arg5 = (long) 0 ;
29471 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29472 wxString *arg6 = (wxString *) &arg6_defvalue ;
29473 wxWindow *result = 0 ;
29474 void *argp1 = 0 ;
29475 int res1 = 0 ;
29476 int val2 ;
29477 int ecode2 = 0 ;
29478 wxPoint temp3 ;
29479 wxSize temp4 ;
29480 long val5 ;
29481 int ecode5 = 0 ;
29482 bool temp6 = false ;
29483 PyObject * obj0 = 0 ;
29484 PyObject * obj1 = 0 ;
29485 PyObject * obj2 = 0 ;
29486 PyObject * obj3 = 0 ;
29487 PyObject * obj4 = 0 ;
29488 PyObject * obj5 = 0 ;
29489 char * kwnames[] = {
29490 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29491 };
29492
29493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29495 if (!SWIG_IsOK(res1)) {
29496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29497 }
29498 arg1 = reinterpret_cast< wxWindow * >(argp1);
29499 if (obj1) {
29500 ecode2 = SWIG_AsVal_int(obj1, &val2);
29501 if (!SWIG_IsOK(ecode2)) {
29502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29503 }
29504 arg2 = static_cast< int >(val2);
29505 }
29506 if (obj2) {
29507 {
29508 arg3 = &temp3;
29509 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29510 }
29511 }
29512 if (obj3) {
29513 {
29514 arg4 = &temp4;
29515 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29516 }
29517 }
29518 if (obj4) {
29519 ecode5 = SWIG_AsVal_long(obj4, &val5);
29520 if (!SWIG_IsOK(ecode5)) {
29521 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29522 }
29523 arg5 = static_cast< long >(val5);
29524 }
29525 if (obj5) {
29526 {
29527 arg6 = wxString_in_helper(obj5);
29528 if (arg6 == NULL) SWIG_fail;
29529 temp6 = true;
29530 }
29531 }
29532 {
29533 if (!wxPyCheckForApp()) SWIG_fail;
29534 PyThreadState* __tstate = wxPyBeginAllowThreads();
29535 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29536 wxPyEndAllowThreads(__tstate);
29537 if (PyErr_Occurred()) SWIG_fail;
29538 }
29539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29540 {
29541 if (temp6)
29542 delete arg6;
29543 }
29544 return resultobj;
29545 fail:
29546 {
29547 if (temp6)
29548 delete arg6;
29549 }
29550 return NULL;
29551 }
29552
29553
29554 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29555 PyObject *resultobj = 0;
29556 wxWindow *result = 0 ;
29557
29558 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29559 {
29560 if (!wxPyCheckForApp()) SWIG_fail;
29561 PyThreadState* __tstate = wxPyBeginAllowThreads();
29562 result = (wxWindow *)new wxWindow();
29563 wxPyEndAllowThreads(__tstate);
29564 if (PyErr_Occurred()) SWIG_fail;
29565 }
29566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29567 return resultobj;
29568 fail:
29569 return NULL;
29570 }
29571
29572
29573 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29574 PyObject *resultobj = 0;
29575 wxWindow *arg1 = (wxWindow *) 0 ;
29576 wxWindow *arg2 = (wxWindow *) 0 ;
29577 int arg3 = (int) (int)-1 ;
29578 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29579 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29580 wxSize const &arg5_defvalue = wxDefaultSize ;
29581 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29582 long arg6 = (long) 0 ;
29583 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29584 wxString *arg7 = (wxString *) &arg7_defvalue ;
29585 bool result;
29586 void *argp1 = 0 ;
29587 int res1 = 0 ;
29588 void *argp2 = 0 ;
29589 int res2 = 0 ;
29590 int val3 ;
29591 int ecode3 = 0 ;
29592 wxPoint temp4 ;
29593 wxSize temp5 ;
29594 long val6 ;
29595 int ecode6 = 0 ;
29596 bool temp7 = false ;
29597 PyObject * obj0 = 0 ;
29598 PyObject * obj1 = 0 ;
29599 PyObject * obj2 = 0 ;
29600 PyObject * obj3 = 0 ;
29601 PyObject * obj4 = 0 ;
29602 PyObject * obj5 = 0 ;
29603 PyObject * obj6 = 0 ;
29604 char * kwnames[] = {
29605 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29606 };
29607
29608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29610 if (!SWIG_IsOK(res1)) {
29611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29612 }
29613 arg1 = reinterpret_cast< wxWindow * >(argp1);
29614 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29615 if (!SWIG_IsOK(res2)) {
29616 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29617 }
29618 arg2 = reinterpret_cast< wxWindow * >(argp2);
29619 if (obj2) {
29620 ecode3 = SWIG_AsVal_int(obj2, &val3);
29621 if (!SWIG_IsOK(ecode3)) {
29622 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29623 }
29624 arg3 = static_cast< int >(val3);
29625 }
29626 if (obj3) {
29627 {
29628 arg4 = &temp4;
29629 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29630 }
29631 }
29632 if (obj4) {
29633 {
29634 arg5 = &temp5;
29635 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29636 }
29637 }
29638 if (obj5) {
29639 ecode6 = SWIG_AsVal_long(obj5, &val6);
29640 if (!SWIG_IsOK(ecode6)) {
29641 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29642 }
29643 arg6 = static_cast< long >(val6);
29644 }
29645 if (obj6) {
29646 {
29647 arg7 = wxString_in_helper(obj6);
29648 if (arg7 == NULL) SWIG_fail;
29649 temp7 = true;
29650 }
29651 }
29652 {
29653 PyThreadState* __tstate = wxPyBeginAllowThreads();
29654 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29655 wxPyEndAllowThreads(__tstate);
29656 if (PyErr_Occurred()) SWIG_fail;
29657 }
29658 {
29659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29660 }
29661 {
29662 if (temp7)
29663 delete arg7;
29664 }
29665 return resultobj;
29666 fail:
29667 {
29668 if (temp7)
29669 delete arg7;
29670 }
29671 return NULL;
29672 }
29673
29674
29675 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29676 PyObject *resultobj = 0;
29677 wxWindow *arg1 = (wxWindow *) 0 ;
29678 bool arg2 = (bool) false ;
29679 bool result;
29680 void *argp1 = 0 ;
29681 int res1 = 0 ;
29682 bool val2 ;
29683 int ecode2 = 0 ;
29684 PyObject * obj0 = 0 ;
29685 PyObject * obj1 = 0 ;
29686 char * kwnames[] = {
29687 (char *) "self",(char *) "force", NULL
29688 };
29689
29690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29692 if (!SWIG_IsOK(res1)) {
29693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29694 }
29695 arg1 = reinterpret_cast< wxWindow * >(argp1);
29696 if (obj1) {
29697 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29698 if (!SWIG_IsOK(ecode2)) {
29699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29700 }
29701 arg2 = static_cast< bool >(val2);
29702 }
29703 {
29704 PyThreadState* __tstate = wxPyBeginAllowThreads();
29705 result = (bool)(arg1)->Close(arg2);
29706 wxPyEndAllowThreads(__tstate);
29707 if (PyErr_Occurred()) SWIG_fail;
29708 }
29709 {
29710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29711 }
29712 return resultobj;
29713 fail:
29714 return NULL;
29715 }
29716
29717
29718 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29719 PyObject *resultobj = 0;
29720 wxWindow *arg1 = (wxWindow *) 0 ;
29721 bool result;
29722 void *argp1 = 0 ;
29723 int res1 = 0 ;
29724 PyObject *swig_obj[1] ;
29725
29726 if (!args) SWIG_fail;
29727 swig_obj[0] = args;
29728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29729 if (!SWIG_IsOK(res1)) {
29730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29731 }
29732 arg1 = reinterpret_cast< wxWindow * >(argp1);
29733 {
29734 PyThreadState* __tstate = wxPyBeginAllowThreads();
29735 result = (bool)(arg1)->Destroy();
29736 wxPyEndAllowThreads(__tstate);
29737 if (PyErr_Occurred()) SWIG_fail;
29738 }
29739 {
29740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29741 }
29742 return resultobj;
29743 fail:
29744 return NULL;
29745 }
29746
29747
29748 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29749 PyObject *resultobj = 0;
29750 wxWindow *arg1 = (wxWindow *) 0 ;
29751 bool result;
29752 void *argp1 = 0 ;
29753 int res1 = 0 ;
29754 PyObject *swig_obj[1] ;
29755
29756 if (!args) SWIG_fail;
29757 swig_obj[0] = args;
29758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29759 if (!SWIG_IsOK(res1)) {
29760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29761 }
29762 arg1 = reinterpret_cast< wxWindow * >(argp1);
29763 {
29764 PyThreadState* __tstate = wxPyBeginAllowThreads();
29765 result = (bool)(arg1)->DestroyChildren();
29766 wxPyEndAllowThreads(__tstate);
29767 if (PyErr_Occurred()) SWIG_fail;
29768 }
29769 {
29770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29771 }
29772 return resultobj;
29773 fail:
29774 return NULL;
29775 }
29776
29777
29778 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29779 PyObject *resultobj = 0;
29780 wxWindow *arg1 = (wxWindow *) 0 ;
29781 bool result;
29782 void *argp1 = 0 ;
29783 int res1 = 0 ;
29784 PyObject *swig_obj[1] ;
29785
29786 if (!args) SWIG_fail;
29787 swig_obj[0] = args;
29788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29789 if (!SWIG_IsOK(res1)) {
29790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29791 }
29792 arg1 = reinterpret_cast< wxWindow * >(argp1);
29793 {
29794 PyThreadState* __tstate = wxPyBeginAllowThreads();
29795 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29796 wxPyEndAllowThreads(__tstate);
29797 if (PyErr_Occurred()) SWIG_fail;
29798 }
29799 {
29800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29801 }
29802 return resultobj;
29803 fail:
29804 return NULL;
29805 }
29806
29807
29808 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29809 PyObject *resultobj = 0;
29810 wxWindow *arg1 = (wxWindow *) 0 ;
29811 wxString *arg2 = 0 ;
29812 void *argp1 = 0 ;
29813 int res1 = 0 ;
29814 bool temp2 = false ;
29815 PyObject * obj0 = 0 ;
29816 PyObject * obj1 = 0 ;
29817 char * kwnames[] = {
29818 (char *) "self",(char *) "label", NULL
29819 };
29820
29821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29823 if (!SWIG_IsOK(res1)) {
29824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29825 }
29826 arg1 = reinterpret_cast< wxWindow * >(argp1);
29827 {
29828 arg2 = wxString_in_helper(obj1);
29829 if (arg2 == NULL) SWIG_fail;
29830 temp2 = true;
29831 }
29832 {
29833 PyThreadState* __tstate = wxPyBeginAllowThreads();
29834 (arg1)->SetLabel((wxString const &)*arg2);
29835 wxPyEndAllowThreads(__tstate);
29836 if (PyErr_Occurred()) SWIG_fail;
29837 }
29838 resultobj = SWIG_Py_Void();
29839 {
29840 if (temp2)
29841 delete arg2;
29842 }
29843 return resultobj;
29844 fail:
29845 {
29846 if (temp2)
29847 delete arg2;
29848 }
29849 return NULL;
29850 }
29851
29852
29853 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29854 PyObject *resultobj = 0;
29855 wxWindow *arg1 = (wxWindow *) 0 ;
29856 wxString result;
29857 void *argp1 = 0 ;
29858 int res1 = 0 ;
29859 PyObject *swig_obj[1] ;
29860
29861 if (!args) SWIG_fail;
29862 swig_obj[0] = args;
29863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29864 if (!SWIG_IsOK(res1)) {
29865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29866 }
29867 arg1 = reinterpret_cast< wxWindow * >(argp1);
29868 {
29869 PyThreadState* __tstate = wxPyBeginAllowThreads();
29870 result = ((wxWindow const *)arg1)->GetLabel();
29871 wxPyEndAllowThreads(__tstate);
29872 if (PyErr_Occurred()) SWIG_fail;
29873 }
29874 {
29875 #if wxUSE_UNICODE
29876 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29877 #else
29878 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29879 #endif
29880 }
29881 return resultobj;
29882 fail:
29883 return NULL;
29884 }
29885
29886
29887 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29888 PyObject *resultobj = 0;
29889 wxWindow *arg1 = (wxWindow *) 0 ;
29890 wxString *arg2 = 0 ;
29891 void *argp1 = 0 ;
29892 int res1 = 0 ;
29893 bool temp2 = false ;
29894 PyObject * obj0 = 0 ;
29895 PyObject * obj1 = 0 ;
29896 char * kwnames[] = {
29897 (char *) "self",(char *) "name", NULL
29898 };
29899
29900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29902 if (!SWIG_IsOK(res1)) {
29903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29904 }
29905 arg1 = reinterpret_cast< wxWindow * >(argp1);
29906 {
29907 arg2 = wxString_in_helper(obj1);
29908 if (arg2 == NULL) SWIG_fail;
29909 temp2 = true;
29910 }
29911 {
29912 PyThreadState* __tstate = wxPyBeginAllowThreads();
29913 (arg1)->SetName((wxString const &)*arg2);
29914 wxPyEndAllowThreads(__tstate);
29915 if (PyErr_Occurred()) SWIG_fail;
29916 }
29917 resultobj = SWIG_Py_Void();
29918 {
29919 if (temp2)
29920 delete arg2;
29921 }
29922 return resultobj;
29923 fail:
29924 {
29925 if (temp2)
29926 delete arg2;
29927 }
29928 return NULL;
29929 }
29930
29931
29932 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29933 PyObject *resultobj = 0;
29934 wxWindow *arg1 = (wxWindow *) 0 ;
29935 wxString result;
29936 void *argp1 = 0 ;
29937 int res1 = 0 ;
29938 PyObject *swig_obj[1] ;
29939
29940 if (!args) SWIG_fail;
29941 swig_obj[0] = args;
29942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29943 if (!SWIG_IsOK(res1)) {
29944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29945 }
29946 arg1 = reinterpret_cast< wxWindow * >(argp1);
29947 {
29948 PyThreadState* __tstate = wxPyBeginAllowThreads();
29949 result = ((wxWindow const *)arg1)->GetName();
29950 wxPyEndAllowThreads(__tstate);
29951 if (PyErr_Occurred()) SWIG_fail;
29952 }
29953 {
29954 #if wxUSE_UNICODE
29955 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29956 #else
29957 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29958 #endif
29959 }
29960 return resultobj;
29961 fail:
29962 return NULL;
29963 }
29964
29965
29966 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29967 PyObject *resultobj = 0;
29968 wxWindow *arg1 = (wxWindow *) 0 ;
29969 wxWindowVariant arg2 ;
29970 void *argp1 = 0 ;
29971 int res1 = 0 ;
29972 int val2 ;
29973 int ecode2 = 0 ;
29974 PyObject * obj0 = 0 ;
29975 PyObject * obj1 = 0 ;
29976 char * kwnames[] = {
29977 (char *) "self",(char *) "variant", NULL
29978 };
29979
29980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29982 if (!SWIG_IsOK(res1)) {
29983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29984 }
29985 arg1 = reinterpret_cast< wxWindow * >(argp1);
29986 ecode2 = SWIG_AsVal_int(obj1, &val2);
29987 if (!SWIG_IsOK(ecode2)) {
29988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29989 }
29990 arg2 = static_cast< wxWindowVariant >(val2);
29991 {
29992 PyThreadState* __tstate = wxPyBeginAllowThreads();
29993 (arg1)->SetWindowVariant(arg2);
29994 wxPyEndAllowThreads(__tstate);
29995 if (PyErr_Occurred()) SWIG_fail;
29996 }
29997 resultobj = SWIG_Py_Void();
29998 return resultobj;
29999 fail:
30000 return NULL;
30001 }
30002
30003
30004 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30005 PyObject *resultobj = 0;
30006 wxWindow *arg1 = (wxWindow *) 0 ;
30007 wxWindowVariant result;
30008 void *argp1 = 0 ;
30009 int res1 = 0 ;
30010 PyObject *swig_obj[1] ;
30011
30012 if (!args) SWIG_fail;
30013 swig_obj[0] = args;
30014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30015 if (!SWIG_IsOK(res1)) {
30016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30017 }
30018 arg1 = reinterpret_cast< wxWindow * >(argp1);
30019 {
30020 PyThreadState* __tstate = wxPyBeginAllowThreads();
30021 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30022 wxPyEndAllowThreads(__tstate);
30023 if (PyErr_Occurred()) SWIG_fail;
30024 }
30025 resultobj = SWIG_From_int(static_cast< int >(result));
30026 return resultobj;
30027 fail:
30028 return NULL;
30029 }
30030
30031
30032 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30033 PyObject *resultobj = 0;
30034 wxWindow *arg1 = (wxWindow *) 0 ;
30035 int arg2 ;
30036 void *argp1 = 0 ;
30037 int res1 = 0 ;
30038 int val2 ;
30039 int ecode2 = 0 ;
30040 PyObject * obj0 = 0 ;
30041 PyObject * obj1 = 0 ;
30042 char * kwnames[] = {
30043 (char *) "self",(char *) "winid", NULL
30044 };
30045
30046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30048 if (!SWIG_IsOK(res1)) {
30049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30050 }
30051 arg1 = reinterpret_cast< wxWindow * >(argp1);
30052 ecode2 = SWIG_AsVal_int(obj1, &val2);
30053 if (!SWIG_IsOK(ecode2)) {
30054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30055 }
30056 arg2 = static_cast< int >(val2);
30057 {
30058 PyThreadState* __tstate = wxPyBeginAllowThreads();
30059 (arg1)->SetId(arg2);
30060 wxPyEndAllowThreads(__tstate);
30061 if (PyErr_Occurred()) SWIG_fail;
30062 }
30063 resultobj = SWIG_Py_Void();
30064 return resultobj;
30065 fail:
30066 return NULL;
30067 }
30068
30069
30070 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30071 PyObject *resultobj = 0;
30072 wxWindow *arg1 = (wxWindow *) 0 ;
30073 int result;
30074 void *argp1 = 0 ;
30075 int res1 = 0 ;
30076 PyObject *swig_obj[1] ;
30077
30078 if (!args) SWIG_fail;
30079 swig_obj[0] = args;
30080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30081 if (!SWIG_IsOK(res1)) {
30082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30083 }
30084 arg1 = reinterpret_cast< wxWindow * >(argp1);
30085 {
30086 PyThreadState* __tstate = wxPyBeginAllowThreads();
30087 result = (int)((wxWindow const *)arg1)->GetId();
30088 wxPyEndAllowThreads(__tstate);
30089 if (PyErr_Occurred()) SWIG_fail;
30090 }
30091 resultobj = SWIG_From_int(static_cast< int >(result));
30092 return resultobj;
30093 fail:
30094 return NULL;
30095 }
30096
30097
30098 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30099 PyObject *resultobj = 0;
30100 int result;
30101
30102 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30103 {
30104 PyThreadState* __tstate = wxPyBeginAllowThreads();
30105 result = (int)wxWindow::NewControlId();
30106 wxPyEndAllowThreads(__tstate);
30107 if (PyErr_Occurred()) SWIG_fail;
30108 }
30109 resultobj = SWIG_From_int(static_cast< int >(result));
30110 return resultobj;
30111 fail:
30112 return NULL;
30113 }
30114
30115
30116 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30117 PyObject *resultobj = 0;
30118 int arg1 ;
30119 int result;
30120 int val1 ;
30121 int ecode1 = 0 ;
30122 PyObject * obj0 = 0 ;
30123 char * kwnames[] = {
30124 (char *) "winid", NULL
30125 };
30126
30127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30128 ecode1 = SWIG_AsVal_int(obj0, &val1);
30129 if (!SWIG_IsOK(ecode1)) {
30130 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30131 }
30132 arg1 = static_cast< int >(val1);
30133 {
30134 PyThreadState* __tstate = wxPyBeginAllowThreads();
30135 result = (int)wxWindow::NextControlId(arg1);
30136 wxPyEndAllowThreads(__tstate);
30137 if (PyErr_Occurred()) SWIG_fail;
30138 }
30139 resultobj = SWIG_From_int(static_cast< int >(result));
30140 return resultobj;
30141 fail:
30142 return NULL;
30143 }
30144
30145
30146 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30147 PyObject *resultobj = 0;
30148 int arg1 ;
30149 int result;
30150 int val1 ;
30151 int ecode1 = 0 ;
30152 PyObject * obj0 = 0 ;
30153 char * kwnames[] = {
30154 (char *) "winid", NULL
30155 };
30156
30157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30158 ecode1 = SWIG_AsVal_int(obj0, &val1);
30159 if (!SWIG_IsOK(ecode1)) {
30160 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30161 }
30162 arg1 = static_cast< int >(val1);
30163 {
30164 PyThreadState* __tstate = wxPyBeginAllowThreads();
30165 result = (int)wxWindow::PrevControlId(arg1);
30166 wxPyEndAllowThreads(__tstate);
30167 if (PyErr_Occurred()) SWIG_fail;
30168 }
30169 resultobj = SWIG_From_int(static_cast< int >(result));
30170 return resultobj;
30171 fail:
30172 return NULL;
30173 }
30174
30175
30176 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30177 PyObject *resultobj = 0;
30178 wxWindow *arg1 = (wxWindow *) 0 ;
30179 wxSize *arg2 = 0 ;
30180 void *argp1 = 0 ;
30181 int res1 = 0 ;
30182 wxSize temp2 ;
30183 PyObject * obj0 = 0 ;
30184 PyObject * obj1 = 0 ;
30185 char * kwnames[] = {
30186 (char *) "self",(char *) "size", NULL
30187 };
30188
30189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30191 if (!SWIG_IsOK(res1)) {
30192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30193 }
30194 arg1 = reinterpret_cast< wxWindow * >(argp1);
30195 {
30196 arg2 = &temp2;
30197 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30198 }
30199 {
30200 PyThreadState* __tstate = wxPyBeginAllowThreads();
30201 (arg1)->SetSize((wxSize const &)*arg2);
30202 wxPyEndAllowThreads(__tstate);
30203 if (PyErr_Occurred()) SWIG_fail;
30204 }
30205 resultobj = SWIG_Py_Void();
30206 return resultobj;
30207 fail:
30208 return NULL;
30209 }
30210
30211
30212 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30213 PyObject *resultobj = 0;
30214 wxWindow *arg1 = (wxWindow *) 0 ;
30215 int arg2 ;
30216 int arg3 ;
30217 int arg4 ;
30218 int arg5 ;
30219 int arg6 = (int) wxSIZE_AUTO ;
30220 void *argp1 = 0 ;
30221 int res1 = 0 ;
30222 int val2 ;
30223 int ecode2 = 0 ;
30224 int val3 ;
30225 int ecode3 = 0 ;
30226 int val4 ;
30227 int ecode4 = 0 ;
30228 int val5 ;
30229 int ecode5 = 0 ;
30230 int val6 ;
30231 int ecode6 = 0 ;
30232 PyObject * obj0 = 0 ;
30233 PyObject * obj1 = 0 ;
30234 PyObject * obj2 = 0 ;
30235 PyObject * obj3 = 0 ;
30236 PyObject * obj4 = 0 ;
30237 PyObject * obj5 = 0 ;
30238 char * kwnames[] = {
30239 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30240 };
30241
30242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30244 if (!SWIG_IsOK(res1)) {
30245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30246 }
30247 arg1 = reinterpret_cast< wxWindow * >(argp1);
30248 ecode2 = SWIG_AsVal_int(obj1, &val2);
30249 if (!SWIG_IsOK(ecode2)) {
30250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30251 }
30252 arg2 = static_cast< int >(val2);
30253 ecode3 = SWIG_AsVal_int(obj2, &val3);
30254 if (!SWIG_IsOK(ecode3)) {
30255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30256 }
30257 arg3 = static_cast< int >(val3);
30258 ecode4 = SWIG_AsVal_int(obj3, &val4);
30259 if (!SWIG_IsOK(ecode4)) {
30260 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30261 }
30262 arg4 = static_cast< int >(val4);
30263 ecode5 = SWIG_AsVal_int(obj4, &val5);
30264 if (!SWIG_IsOK(ecode5)) {
30265 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30266 }
30267 arg5 = static_cast< int >(val5);
30268 if (obj5) {
30269 ecode6 = SWIG_AsVal_int(obj5, &val6);
30270 if (!SWIG_IsOK(ecode6)) {
30271 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30272 }
30273 arg6 = static_cast< int >(val6);
30274 }
30275 {
30276 PyThreadState* __tstate = wxPyBeginAllowThreads();
30277 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30278 wxPyEndAllowThreads(__tstate);
30279 if (PyErr_Occurred()) SWIG_fail;
30280 }
30281 resultobj = SWIG_Py_Void();
30282 return resultobj;
30283 fail:
30284 return NULL;
30285 }
30286
30287
30288 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30289 PyObject *resultobj = 0;
30290 wxWindow *arg1 = (wxWindow *) 0 ;
30291 wxRect *arg2 = 0 ;
30292 int arg3 = (int) wxSIZE_AUTO ;
30293 void *argp1 = 0 ;
30294 int res1 = 0 ;
30295 wxRect temp2 ;
30296 int val3 ;
30297 int ecode3 = 0 ;
30298 PyObject * obj0 = 0 ;
30299 PyObject * obj1 = 0 ;
30300 PyObject * obj2 = 0 ;
30301 char * kwnames[] = {
30302 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30303 };
30304
30305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30307 if (!SWIG_IsOK(res1)) {
30308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30309 }
30310 arg1 = reinterpret_cast< wxWindow * >(argp1);
30311 {
30312 arg2 = &temp2;
30313 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30314 }
30315 if (obj2) {
30316 ecode3 = SWIG_AsVal_int(obj2, &val3);
30317 if (!SWIG_IsOK(ecode3)) {
30318 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30319 }
30320 arg3 = static_cast< int >(val3);
30321 }
30322 {
30323 PyThreadState* __tstate = wxPyBeginAllowThreads();
30324 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30325 wxPyEndAllowThreads(__tstate);
30326 if (PyErr_Occurred()) SWIG_fail;
30327 }
30328 resultobj = SWIG_Py_Void();
30329 return resultobj;
30330 fail:
30331 return NULL;
30332 }
30333
30334
30335 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30336 PyObject *resultobj = 0;
30337 wxWindow *arg1 = (wxWindow *) 0 ;
30338 int arg2 ;
30339 int arg3 ;
30340 void *argp1 = 0 ;
30341 int res1 = 0 ;
30342 int val2 ;
30343 int ecode2 = 0 ;
30344 int val3 ;
30345 int ecode3 = 0 ;
30346 PyObject * obj0 = 0 ;
30347 PyObject * obj1 = 0 ;
30348 PyObject * obj2 = 0 ;
30349 char * kwnames[] = {
30350 (char *) "self",(char *) "width",(char *) "height", NULL
30351 };
30352
30353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30355 if (!SWIG_IsOK(res1)) {
30356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30357 }
30358 arg1 = reinterpret_cast< wxWindow * >(argp1);
30359 ecode2 = SWIG_AsVal_int(obj1, &val2);
30360 if (!SWIG_IsOK(ecode2)) {
30361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30362 }
30363 arg2 = static_cast< int >(val2);
30364 ecode3 = SWIG_AsVal_int(obj2, &val3);
30365 if (!SWIG_IsOK(ecode3)) {
30366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30367 }
30368 arg3 = static_cast< int >(val3);
30369 {
30370 PyThreadState* __tstate = wxPyBeginAllowThreads();
30371 (arg1)->SetSize(arg2,arg3);
30372 wxPyEndAllowThreads(__tstate);
30373 if (PyErr_Occurred()) SWIG_fail;
30374 }
30375 resultobj = SWIG_Py_Void();
30376 return resultobj;
30377 fail:
30378 return NULL;
30379 }
30380
30381
30382 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30383 PyObject *resultobj = 0;
30384 wxWindow *arg1 = (wxWindow *) 0 ;
30385 wxPoint *arg2 = 0 ;
30386 int arg3 = (int) wxSIZE_USE_EXISTING ;
30387 void *argp1 = 0 ;
30388 int res1 = 0 ;
30389 wxPoint temp2 ;
30390 int val3 ;
30391 int ecode3 = 0 ;
30392 PyObject * obj0 = 0 ;
30393 PyObject * obj1 = 0 ;
30394 PyObject * obj2 = 0 ;
30395 char * kwnames[] = {
30396 (char *) "self",(char *) "pt",(char *) "flags", NULL
30397 };
30398
30399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30401 if (!SWIG_IsOK(res1)) {
30402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30403 }
30404 arg1 = reinterpret_cast< wxWindow * >(argp1);
30405 {
30406 arg2 = &temp2;
30407 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30408 }
30409 if (obj2) {
30410 ecode3 = SWIG_AsVal_int(obj2, &val3);
30411 if (!SWIG_IsOK(ecode3)) {
30412 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30413 }
30414 arg3 = static_cast< int >(val3);
30415 }
30416 {
30417 PyThreadState* __tstate = wxPyBeginAllowThreads();
30418 (arg1)->Move((wxPoint const &)*arg2,arg3);
30419 wxPyEndAllowThreads(__tstate);
30420 if (PyErr_Occurred()) SWIG_fail;
30421 }
30422 resultobj = SWIG_Py_Void();
30423 return resultobj;
30424 fail:
30425 return NULL;
30426 }
30427
30428
30429 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30430 PyObject *resultobj = 0;
30431 wxWindow *arg1 = (wxWindow *) 0 ;
30432 int arg2 ;
30433 int arg3 ;
30434 int arg4 = (int) wxSIZE_USE_EXISTING ;
30435 void *argp1 = 0 ;
30436 int res1 = 0 ;
30437 int val2 ;
30438 int ecode2 = 0 ;
30439 int val3 ;
30440 int ecode3 = 0 ;
30441 int val4 ;
30442 int ecode4 = 0 ;
30443 PyObject * obj0 = 0 ;
30444 PyObject * obj1 = 0 ;
30445 PyObject * obj2 = 0 ;
30446 PyObject * obj3 = 0 ;
30447 char * kwnames[] = {
30448 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30449 };
30450
30451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30453 if (!SWIG_IsOK(res1)) {
30454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30455 }
30456 arg1 = reinterpret_cast< wxWindow * >(argp1);
30457 ecode2 = SWIG_AsVal_int(obj1, &val2);
30458 if (!SWIG_IsOK(ecode2)) {
30459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30460 }
30461 arg2 = static_cast< int >(val2);
30462 ecode3 = SWIG_AsVal_int(obj2, &val3);
30463 if (!SWIG_IsOK(ecode3)) {
30464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30465 }
30466 arg3 = static_cast< int >(val3);
30467 if (obj3) {
30468 ecode4 = SWIG_AsVal_int(obj3, &val4);
30469 if (!SWIG_IsOK(ecode4)) {
30470 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30471 }
30472 arg4 = static_cast< int >(val4);
30473 }
30474 {
30475 PyThreadState* __tstate = wxPyBeginAllowThreads();
30476 (arg1)->Move(arg2,arg3,arg4);
30477 wxPyEndAllowThreads(__tstate);
30478 if (PyErr_Occurred()) SWIG_fail;
30479 }
30480 resultobj = SWIG_Py_Void();
30481 return resultobj;
30482 fail:
30483 return NULL;
30484 }
30485
30486
30487 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30488 PyObject *resultobj = 0;
30489 wxWindow *arg1 = (wxWindow *) 0 ;
30490 wxSize const &arg2_defvalue = wxDefaultSize ;
30491 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30492 void *argp1 = 0 ;
30493 int res1 = 0 ;
30494 wxSize temp2 ;
30495 PyObject * obj0 = 0 ;
30496 PyObject * obj1 = 0 ;
30497 char * kwnames[] = {
30498 (char *) "self",(char *) "size", NULL
30499 };
30500
30501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30503 if (!SWIG_IsOK(res1)) {
30504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30505 }
30506 arg1 = reinterpret_cast< wxWindow * >(argp1);
30507 if (obj1) {
30508 {
30509 arg2 = &temp2;
30510 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30511 }
30512 }
30513 {
30514 PyThreadState* __tstate = wxPyBeginAllowThreads();
30515 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30516 wxPyEndAllowThreads(__tstate);
30517 if (PyErr_Occurred()) SWIG_fail;
30518 }
30519 resultobj = SWIG_Py_Void();
30520 return resultobj;
30521 fail:
30522 return NULL;
30523 }
30524
30525
30526 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30527 PyObject *resultobj = 0;
30528 wxWindow *arg1 = (wxWindow *) 0 ;
30529 void *argp1 = 0 ;
30530 int res1 = 0 ;
30531 PyObject *swig_obj[1] ;
30532
30533 if (!args) SWIG_fail;
30534 swig_obj[0] = args;
30535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30536 if (!SWIG_IsOK(res1)) {
30537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30538 }
30539 arg1 = reinterpret_cast< wxWindow * >(argp1);
30540 {
30541 PyThreadState* __tstate = wxPyBeginAllowThreads();
30542 (arg1)->Raise();
30543 wxPyEndAllowThreads(__tstate);
30544 if (PyErr_Occurred()) SWIG_fail;
30545 }
30546 resultobj = SWIG_Py_Void();
30547 return resultobj;
30548 fail:
30549 return NULL;
30550 }
30551
30552
30553 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30554 PyObject *resultobj = 0;
30555 wxWindow *arg1 = (wxWindow *) 0 ;
30556 void *argp1 = 0 ;
30557 int res1 = 0 ;
30558 PyObject *swig_obj[1] ;
30559
30560 if (!args) SWIG_fail;
30561 swig_obj[0] = args;
30562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30563 if (!SWIG_IsOK(res1)) {
30564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30565 }
30566 arg1 = reinterpret_cast< wxWindow * >(argp1);
30567 {
30568 PyThreadState* __tstate = wxPyBeginAllowThreads();
30569 (arg1)->Lower();
30570 wxPyEndAllowThreads(__tstate);
30571 if (PyErr_Occurred()) SWIG_fail;
30572 }
30573 resultobj = SWIG_Py_Void();
30574 return resultobj;
30575 fail:
30576 return NULL;
30577 }
30578
30579
30580 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30581 PyObject *resultobj = 0;
30582 wxWindow *arg1 = (wxWindow *) 0 ;
30583 wxSize *arg2 = 0 ;
30584 void *argp1 = 0 ;
30585 int res1 = 0 ;
30586 wxSize temp2 ;
30587 PyObject * obj0 = 0 ;
30588 PyObject * obj1 = 0 ;
30589 char * kwnames[] = {
30590 (char *) "self",(char *) "size", NULL
30591 };
30592
30593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30595 if (!SWIG_IsOK(res1)) {
30596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30597 }
30598 arg1 = reinterpret_cast< wxWindow * >(argp1);
30599 {
30600 arg2 = &temp2;
30601 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30602 }
30603 {
30604 PyThreadState* __tstate = wxPyBeginAllowThreads();
30605 (arg1)->SetClientSize((wxSize const &)*arg2);
30606 wxPyEndAllowThreads(__tstate);
30607 if (PyErr_Occurred()) SWIG_fail;
30608 }
30609 resultobj = SWIG_Py_Void();
30610 return resultobj;
30611 fail:
30612 return NULL;
30613 }
30614
30615
30616 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30617 PyObject *resultobj = 0;
30618 wxWindow *arg1 = (wxWindow *) 0 ;
30619 int arg2 ;
30620 int arg3 ;
30621 void *argp1 = 0 ;
30622 int res1 = 0 ;
30623 int val2 ;
30624 int ecode2 = 0 ;
30625 int val3 ;
30626 int ecode3 = 0 ;
30627 PyObject * obj0 = 0 ;
30628 PyObject * obj1 = 0 ;
30629 PyObject * obj2 = 0 ;
30630 char * kwnames[] = {
30631 (char *) "self",(char *) "width",(char *) "height", NULL
30632 };
30633
30634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30636 if (!SWIG_IsOK(res1)) {
30637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30638 }
30639 arg1 = reinterpret_cast< wxWindow * >(argp1);
30640 ecode2 = SWIG_AsVal_int(obj1, &val2);
30641 if (!SWIG_IsOK(ecode2)) {
30642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30643 }
30644 arg2 = static_cast< int >(val2);
30645 ecode3 = SWIG_AsVal_int(obj2, &val3);
30646 if (!SWIG_IsOK(ecode3)) {
30647 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30648 }
30649 arg3 = static_cast< int >(val3);
30650 {
30651 PyThreadState* __tstate = wxPyBeginAllowThreads();
30652 (arg1)->SetClientSize(arg2,arg3);
30653 wxPyEndAllowThreads(__tstate);
30654 if (PyErr_Occurred()) SWIG_fail;
30655 }
30656 resultobj = SWIG_Py_Void();
30657 return resultobj;
30658 fail:
30659 return NULL;
30660 }
30661
30662
30663 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30664 PyObject *resultobj = 0;
30665 wxWindow *arg1 = (wxWindow *) 0 ;
30666 wxRect *arg2 = 0 ;
30667 void *argp1 = 0 ;
30668 int res1 = 0 ;
30669 wxRect temp2 ;
30670 PyObject * obj0 = 0 ;
30671 PyObject * obj1 = 0 ;
30672 char * kwnames[] = {
30673 (char *) "self",(char *) "rect", NULL
30674 };
30675
30676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30678 if (!SWIG_IsOK(res1)) {
30679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30680 }
30681 arg1 = reinterpret_cast< wxWindow * >(argp1);
30682 {
30683 arg2 = &temp2;
30684 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30685 }
30686 {
30687 PyThreadState* __tstate = wxPyBeginAllowThreads();
30688 (arg1)->SetClientSize((wxRect const &)*arg2);
30689 wxPyEndAllowThreads(__tstate);
30690 if (PyErr_Occurred()) SWIG_fail;
30691 }
30692 resultobj = SWIG_Py_Void();
30693 return resultobj;
30694 fail:
30695 return NULL;
30696 }
30697
30698
30699 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30700 PyObject *resultobj = 0;
30701 wxWindow *arg1 = (wxWindow *) 0 ;
30702 wxPoint result;
30703 void *argp1 = 0 ;
30704 int res1 = 0 ;
30705 PyObject *swig_obj[1] ;
30706
30707 if (!args) SWIG_fail;
30708 swig_obj[0] = args;
30709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30710 if (!SWIG_IsOK(res1)) {
30711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30712 }
30713 arg1 = reinterpret_cast< wxWindow * >(argp1);
30714 {
30715 PyThreadState* __tstate = wxPyBeginAllowThreads();
30716 result = ((wxWindow const *)arg1)->GetPosition();
30717 wxPyEndAllowThreads(__tstate);
30718 if (PyErr_Occurred()) SWIG_fail;
30719 }
30720 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30721 return resultobj;
30722 fail:
30723 return NULL;
30724 }
30725
30726
30727 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30728 PyObject *resultobj = 0;
30729 wxWindow *arg1 = (wxWindow *) 0 ;
30730 int *arg2 = (int *) 0 ;
30731 int *arg3 = (int *) 0 ;
30732 void *argp1 = 0 ;
30733 int res1 = 0 ;
30734 int temp2 ;
30735 int res2 = SWIG_TMPOBJ ;
30736 int temp3 ;
30737 int res3 = SWIG_TMPOBJ ;
30738 PyObject *swig_obj[1] ;
30739
30740 arg2 = &temp2;
30741 arg3 = &temp3;
30742 if (!args) SWIG_fail;
30743 swig_obj[0] = args;
30744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30745 if (!SWIG_IsOK(res1)) {
30746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30747 }
30748 arg1 = reinterpret_cast< wxWindow * >(argp1);
30749 {
30750 PyThreadState* __tstate = wxPyBeginAllowThreads();
30751 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30752 wxPyEndAllowThreads(__tstate);
30753 if (PyErr_Occurred()) SWIG_fail;
30754 }
30755 resultobj = SWIG_Py_Void();
30756 if (SWIG_IsTmpObj(res2)) {
30757 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30758 } else {
30759 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30760 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30761 }
30762 if (SWIG_IsTmpObj(res3)) {
30763 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30764 } else {
30765 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30766 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30767 }
30768 return resultobj;
30769 fail:
30770 return NULL;
30771 }
30772
30773
30774 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30775 PyObject *resultobj = 0;
30776 wxWindow *arg1 = (wxWindow *) 0 ;
30777 wxPoint result;
30778 void *argp1 = 0 ;
30779 int res1 = 0 ;
30780 PyObject *swig_obj[1] ;
30781
30782 if (!args) SWIG_fail;
30783 swig_obj[0] = args;
30784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30785 if (!SWIG_IsOK(res1)) {
30786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30787 }
30788 arg1 = reinterpret_cast< wxWindow * >(argp1);
30789 {
30790 PyThreadState* __tstate = wxPyBeginAllowThreads();
30791 result = ((wxWindow const *)arg1)->GetScreenPosition();
30792 wxPyEndAllowThreads(__tstate);
30793 if (PyErr_Occurred()) SWIG_fail;
30794 }
30795 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30796 return resultobj;
30797 fail:
30798 return NULL;
30799 }
30800
30801
30802 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30803 PyObject *resultobj = 0;
30804 wxWindow *arg1 = (wxWindow *) 0 ;
30805 int *arg2 = (int *) 0 ;
30806 int *arg3 = (int *) 0 ;
30807 void *argp1 = 0 ;
30808 int res1 = 0 ;
30809 int temp2 ;
30810 int res2 = SWIG_TMPOBJ ;
30811 int temp3 ;
30812 int res3 = SWIG_TMPOBJ ;
30813 PyObject *swig_obj[1] ;
30814
30815 arg2 = &temp2;
30816 arg3 = &temp3;
30817 if (!args) SWIG_fail;
30818 swig_obj[0] = args;
30819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30820 if (!SWIG_IsOK(res1)) {
30821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30822 }
30823 arg1 = reinterpret_cast< wxWindow * >(argp1);
30824 {
30825 PyThreadState* __tstate = wxPyBeginAllowThreads();
30826 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30827 wxPyEndAllowThreads(__tstate);
30828 if (PyErr_Occurred()) SWIG_fail;
30829 }
30830 resultobj = SWIG_Py_Void();
30831 if (SWIG_IsTmpObj(res2)) {
30832 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30833 } else {
30834 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30835 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30836 }
30837 if (SWIG_IsTmpObj(res3)) {
30838 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30839 } else {
30840 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30841 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30842 }
30843 return resultobj;
30844 fail:
30845 return NULL;
30846 }
30847
30848
30849 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30850 PyObject *resultobj = 0;
30851 wxWindow *arg1 = (wxWindow *) 0 ;
30852 wxRect result;
30853 void *argp1 = 0 ;
30854 int res1 = 0 ;
30855 PyObject *swig_obj[1] ;
30856
30857 if (!args) SWIG_fail;
30858 swig_obj[0] = args;
30859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30860 if (!SWIG_IsOK(res1)) {
30861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30862 }
30863 arg1 = reinterpret_cast< wxWindow * >(argp1);
30864 {
30865 PyThreadState* __tstate = wxPyBeginAllowThreads();
30866 result = ((wxWindow const *)arg1)->GetScreenRect();
30867 wxPyEndAllowThreads(__tstate);
30868 if (PyErr_Occurred()) SWIG_fail;
30869 }
30870 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30871 return resultobj;
30872 fail:
30873 return NULL;
30874 }
30875
30876
30877 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30878 PyObject *resultobj = 0;
30879 wxWindow *arg1 = (wxWindow *) 0 ;
30880 wxSize result;
30881 void *argp1 = 0 ;
30882 int res1 = 0 ;
30883 PyObject *swig_obj[1] ;
30884
30885 if (!args) SWIG_fail;
30886 swig_obj[0] = args;
30887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30888 if (!SWIG_IsOK(res1)) {
30889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30890 }
30891 arg1 = reinterpret_cast< wxWindow * >(argp1);
30892 {
30893 PyThreadState* __tstate = wxPyBeginAllowThreads();
30894 result = ((wxWindow const *)arg1)->GetSize();
30895 wxPyEndAllowThreads(__tstate);
30896 if (PyErr_Occurred()) SWIG_fail;
30897 }
30898 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30899 return resultobj;
30900 fail:
30901 return NULL;
30902 }
30903
30904
30905 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30906 PyObject *resultobj = 0;
30907 wxWindow *arg1 = (wxWindow *) 0 ;
30908 int *arg2 = (int *) 0 ;
30909 int *arg3 = (int *) 0 ;
30910 void *argp1 = 0 ;
30911 int res1 = 0 ;
30912 int temp2 ;
30913 int res2 = SWIG_TMPOBJ ;
30914 int temp3 ;
30915 int res3 = SWIG_TMPOBJ ;
30916 PyObject *swig_obj[1] ;
30917
30918 arg2 = &temp2;
30919 arg3 = &temp3;
30920 if (!args) SWIG_fail;
30921 swig_obj[0] = args;
30922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30923 if (!SWIG_IsOK(res1)) {
30924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30925 }
30926 arg1 = reinterpret_cast< wxWindow * >(argp1);
30927 {
30928 PyThreadState* __tstate = wxPyBeginAllowThreads();
30929 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30930 wxPyEndAllowThreads(__tstate);
30931 if (PyErr_Occurred()) SWIG_fail;
30932 }
30933 resultobj = SWIG_Py_Void();
30934 if (SWIG_IsTmpObj(res2)) {
30935 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30936 } else {
30937 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30938 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30939 }
30940 if (SWIG_IsTmpObj(res3)) {
30941 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30942 } else {
30943 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30944 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30945 }
30946 return resultobj;
30947 fail:
30948 return NULL;
30949 }
30950
30951
30952 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30953 PyObject *resultobj = 0;
30954 wxWindow *arg1 = (wxWindow *) 0 ;
30955 wxRect result;
30956 void *argp1 = 0 ;
30957 int res1 = 0 ;
30958 PyObject *swig_obj[1] ;
30959
30960 if (!args) SWIG_fail;
30961 swig_obj[0] = args;
30962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30963 if (!SWIG_IsOK(res1)) {
30964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30965 }
30966 arg1 = reinterpret_cast< wxWindow * >(argp1);
30967 {
30968 PyThreadState* __tstate = wxPyBeginAllowThreads();
30969 result = ((wxWindow const *)arg1)->GetRect();
30970 wxPyEndAllowThreads(__tstate);
30971 if (PyErr_Occurred()) SWIG_fail;
30972 }
30973 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30974 return resultobj;
30975 fail:
30976 return NULL;
30977 }
30978
30979
30980 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30981 PyObject *resultobj = 0;
30982 wxWindow *arg1 = (wxWindow *) 0 ;
30983 wxSize result;
30984 void *argp1 = 0 ;
30985 int res1 = 0 ;
30986 PyObject *swig_obj[1] ;
30987
30988 if (!args) SWIG_fail;
30989 swig_obj[0] = args;
30990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30991 if (!SWIG_IsOK(res1)) {
30992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30993 }
30994 arg1 = reinterpret_cast< wxWindow * >(argp1);
30995 {
30996 PyThreadState* __tstate = wxPyBeginAllowThreads();
30997 result = ((wxWindow const *)arg1)->GetClientSize();
30998 wxPyEndAllowThreads(__tstate);
30999 if (PyErr_Occurred()) SWIG_fail;
31000 }
31001 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31002 return resultobj;
31003 fail:
31004 return NULL;
31005 }
31006
31007
31008 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31009 PyObject *resultobj = 0;
31010 wxWindow *arg1 = (wxWindow *) 0 ;
31011 int *arg2 = (int *) 0 ;
31012 int *arg3 = (int *) 0 ;
31013 void *argp1 = 0 ;
31014 int res1 = 0 ;
31015 int temp2 ;
31016 int res2 = SWIG_TMPOBJ ;
31017 int temp3 ;
31018 int res3 = SWIG_TMPOBJ ;
31019 PyObject *swig_obj[1] ;
31020
31021 arg2 = &temp2;
31022 arg3 = &temp3;
31023 if (!args) SWIG_fail;
31024 swig_obj[0] = args;
31025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31026 if (!SWIG_IsOK(res1)) {
31027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31028 }
31029 arg1 = reinterpret_cast< wxWindow * >(argp1);
31030 {
31031 PyThreadState* __tstate = wxPyBeginAllowThreads();
31032 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31033 wxPyEndAllowThreads(__tstate);
31034 if (PyErr_Occurred()) SWIG_fail;
31035 }
31036 resultobj = SWIG_Py_Void();
31037 if (SWIG_IsTmpObj(res2)) {
31038 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31039 } else {
31040 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31041 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31042 }
31043 if (SWIG_IsTmpObj(res3)) {
31044 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31045 } else {
31046 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31047 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31048 }
31049 return resultobj;
31050 fail:
31051 return NULL;
31052 }
31053
31054
31055 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31056 PyObject *resultobj = 0;
31057 wxWindow *arg1 = (wxWindow *) 0 ;
31058 wxPoint result;
31059 void *argp1 = 0 ;
31060 int res1 = 0 ;
31061 PyObject *swig_obj[1] ;
31062
31063 if (!args) SWIG_fail;
31064 swig_obj[0] = args;
31065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31066 if (!SWIG_IsOK(res1)) {
31067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31068 }
31069 arg1 = reinterpret_cast< wxWindow * >(argp1);
31070 {
31071 PyThreadState* __tstate = wxPyBeginAllowThreads();
31072 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31073 wxPyEndAllowThreads(__tstate);
31074 if (PyErr_Occurred()) SWIG_fail;
31075 }
31076 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31077 return resultobj;
31078 fail:
31079 return NULL;
31080 }
31081
31082
31083 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31084 PyObject *resultobj = 0;
31085 wxWindow *arg1 = (wxWindow *) 0 ;
31086 wxRect result;
31087 void *argp1 = 0 ;
31088 int res1 = 0 ;
31089 PyObject *swig_obj[1] ;
31090
31091 if (!args) SWIG_fail;
31092 swig_obj[0] = args;
31093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31094 if (!SWIG_IsOK(res1)) {
31095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31096 }
31097 arg1 = reinterpret_cast< wxWindow * >(argp1);
31098 {
31099 PyThreadState* __tstate = wxPyBeginAllowThreads();
31100 result = ((wxWindow const *)arg1)->GetClientRect();
31101 wxPyEndAllowThreads(__tstate);
31102 if (PyErr_Occurred()) SWIG_fail;
31103 }
31104 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31105 return resultobj;
31106 fail:
31107 return NULL;
31108 }
31109
31110
31111 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31112 PyObject *resultobj = 0;
31113 wxWindow *arg1 = (wxWindow *) 0 ;
31114 wxSize result;
31115 void *argp1 = 0 ;
31116 int res1 = 0 ;
31117 PyObject *swig_obj[1] ;
31118
31119 if (!args) SWIG_fail;
31120 swig_obj[0] = args;
31121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31122 if (!SWIG_IsOK(res1)) {
31123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31124 }
31125 arg1 = reinterpret_cast< wxWindow * >(argp1);
31126 {
31127 PyThreadState* __tstate = wxPyBeginAllowThreads();
31128 result = ((wxWindow const *)arg1)->GetBestSize();
31129 wxPyEndAllowThreads(__tstate);
31130 if (PyErr_Occurred()) SWIG_fail;
31131 }
31132 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31133 return resultobj;
31134 fail:
31135 return NULL;
31136 }
31137
31138
31139 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31140 PyObject *resultobj = 0;
31141 wxWindow *arg1 = (wxWindow *) 0 ;
31142 int *arg2 = (int *) 0 ;
31143 int *arg3 = (int *) 0 ;
31144 void *argp1 = 0 ;
31145 int res1 = 0 ;
31146 int temp2 ;
31147 int res2 = SWIG_TMPOBJ ;
31148 int temp3 ;
31149 int res3 = SWIG_TMPOBJ ;
31150 PyObject *swig_obj[1] ;
31151
31152 arg2 = &temp2;
31153 arg3 = &temp3;
31154 if (!args) SWIG_fail;
31155 swig_obj[0] = args;
31156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31157 if (!SWIG_IsOK(res1)) {
31158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31159 }
31160 arg1 = reinterpret_cast< wxWindow * >(argp1);
31161 {
31162 PyThreadState* __tstate = wxPyBeginAllowThreads();
31163 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31164 wxPyEndAllowThreads(__tstate);
31165 if (PyErr_Occurred()) SWIG_fail;
31166 }
31167 resultobj = SWIG_Py_Void();
31168 if (SWIG_IsTmpObj(res2)) {
31169 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31170 } else {
31171 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31172 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31173 }
31174 if (SWIG_IsTmpObj(res3)) {
31175 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31176 } else {
31177 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31178 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31179 }
31180 return resultobj;
31181 fail:
31182 return NULL;
31183 }
31184
31185
31186 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31187 PyObject *resultobj = 0;
31188 wxWindow *arg1 = (wxWindow *) 0 ;
31189 void *argp1 = 0 ;
31190 int res1 = 0 ;
31191 PyObject *swig_obj[1] ;
31192
31193 if (!args) SWIG_fail;
31194 swig_obj[0] = args;
31195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31196 if (!SWIG_IsOK(res1)) {
31197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31198 }
31199 arg1 = reinterpret_cast< wxWindow * >(argp1);
31200 {
31201 PyThreadState* __tstate = wxPyBeginAllowThreads();
31202 (arg1)->InvalidateBestSize();
31203 wxPyEndAllowThreads(__tstate);
31204 if (PyErr_Occurred()) SWIG_fail;
31205 }
31206 resultobj = SWIG_Py_Void();
31207 return resultobj;
31208 fail:
31209 return NULL;
31210 }
31211
31212
31213 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31214 PyObject *resultobj = 0;
31215 wxWindow *arg1 = (wxWindow *) 0 ;
31216 wxSize *arg2 = 0 ;
31217 void *argp1 = 0 ;
31218 int res1 = 0 ;
31219 wxSize temp2 ;
31220 PyObject * obj0 = 0 ;
31221 PyObject * obj1 = 0 ;
31222 char * kwnames[] = {
31223 (char *) "self",(char *) "size", NULL
31224 };
31225
31226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31228 if (!SWIG_IsOK(res1)) {
31229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31230 }
31231 arg1 = reinterpret_cast< wxWindow * >(argp1);
31232 {
31233 arg2 = &temp2;
31234 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31235 }
31236 {
31237 PyThreadState* __tstate = wxPyBeginAllowThreads();
31238 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31239 wxPyEndAllowThreads(__tstate);
31240 if (PyErr_Occurred()) SWIG_fail;
31241 }
31242 resultobj = SWIG_Py_Void();
31243 return resultobj;
31244 fail:
31245 return NULL;
31246 }
31247
31248
31249 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31250 PyObject *resultobj = 0;
31251 wxWindow *arg1 = (wxWindow *) 0 ;
31252 wxSize result;
31253 void *argp1 = 0 ;
31254 int res1 = 0 ;
31255 PyObject *swig_obj[1] ;
31256
31257 if (!args) SWIG_fail;
31258 swig_obj[0] = args;
31259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31260 if (!SWIG_IsOK(res1)) {
31261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31262 }
31263 arg1 = reinterpret_cast< wxWindow * >(argp1);
31264 {
31265 PyThreadState* __tstate = wxPyBeginAllowThreads();
31266 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31267 wxPyEndAllowThreads(__tstate);
31268 if (PyErr_Occurred()) SWIG_fail;
31269 }
31270 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31271 return resultobj;
31272 fail:
31273 return NULL;
31274 }
31275
31276
31277 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31278 PyObject *resultobj = 0;
31279 wxWindow *arg1 = (wxWindow *) 0 ;
31280 wxSize result;
31281 void *argp1 = 0 ;
31282 int res1 = 0 ;
31283 PyObject *swig_obj[1] ;
31284
31285 if (!args) SWIG_fail;
31286 swig_obj[0] = args;
31287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31288 if (!SWIG_IsOK(res1)) {
31289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31290 }
31291 arg1 = reinterpret_cast< wxWindow * >(argp1);
31292 {
31293 PyThreadState* __tstate = wxPyBeginAllowThreads();
31294 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31295 wxPyEndAllowThreads(__tstate);
31296 if (PyErr_Occurred()) SWIG_fail;
31297 }
31298 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31299 return resultobj;
31300 fail:
31301 return NULL;
31302 }
31303
31304
31305 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31306 PyObject *resultobj = 0;
31307 wxWindow *arg1 = (wxWindow *) 0 ;
31308 int arg2 = (int) wxBOTH ;
31309 void *argp1 = 0 ;
31310 int res1 = 0 ;
31311 int val2 ;
31312 int ecode2 = 0 ;
31313 PyObject * obj0 = 0 ;
31314 PyObject * obj1 = 0 ;
31315 char * kwnames[] = {
31316 (char *) "self",(char *) "direction", NULL
31317 };
31318
31319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31321 if (!SWIG_IsOK(res1)) {
31322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31323 }
31324 arg1 = reinterpret_cast< wxWindow * >(argp1);
31325 if (obj1) {
31326 ecode2 = SWIG_AsVal_int(obj1, &val2);
31327 if (!SWIG_IsOK(ecode2)) {
31328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31329 }
31330 arg2 = static_cast< int >(val2);
31331 }
31332 {
31333 PyThreadState* __tstate = wxPyBeginAllowThreads();
31334 (arg1)->Center(arg2);
31335 wxPyEndAllowThreads(__tstate);
31336 if (PyErr_Occurred()) SWIG_fail;
31337 }
31338 resultobj = SWIG_Py_Void();
31339 return resultobj;
31340 fail:
31341 return NULL;
31342 }
31343
31344
31345 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31346 PyObject *resultobj = 0;
31347 wxWindow *arg1 = (wxWindow *) 0 ;
31348 int arg2 = (int) wxBOTH ;
31349 void *argp1 = 0 ;
31350 int res1 = 0 ;
31351 int val2 ;
31352 int ecode2 = 0 ;
31353 PyObject * obj0 = 0 ;
31354 PyObject * obj1 = 0 ;
31355 char * kwnames[] = {
31356 (char *) "self",(char *) "dir", NULL
31357 };
31358
31359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31361 if (!SWIG_IsOK(res1)) {
31362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31363 }
31364 arg1 = reinterpret_cast< wxWindow * >(argp1);
31365 if (obj1) {
31366 ecode2 = SWIG_AsVal_int(obj1, &val2);
31367 if (!SWIG_IsOK(ecode2)) {
31368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31369 }
31370 arg2 = static_cast< int >(val2);
31371 }
31372 {
31373 PyThreadState* __tstate = wxPyBeginAllowThreads();
31374 (arg1)->CenterOnParent(arg2);
31375 wxPyEndAllowThreads(__tstate);
31376 if (PyErr_Occurred()) SWIG_fail;
31377 }
31378 resultobj = SWIG_Py_Void();
31379 return resultobj;
31380 fail:
31381 return NULL;
31382 }
31383
31384
31385 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31386 PyObject *resultobj = 0;
31387 wxWindow *arg1 = (wxWindow *) 0 ;
31388 void *argp1 = 0 ;
31389 int res1 = 0 ;
31390 PyObject *swig_obj[1] ;
31391
31392 if (!args) SWIG_fail;
31393 swig_obj[0] = args;
31394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31395 if (!SWIG_IsOK(res1)) {
31396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31397 }
31398 arg1 = reinterpret_cast< wxWindow * >(argp1);
31399 {
31400 PyThreadState* __tstate = wxPyBeginAllowThreads();
31401 (arg1)->Fit();
31402 wxPyEndAllowThreads(__tstate);
31403 if (PyErr_Occurred()) SWIG_fail;
31404 }
31405 resultobj = SWIG_Py_Void();
31406 return resultobj;
31407 fail:
31408 return NULL;
31409 }
31410
31411
31412 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31413 PyObject *resultobj = 0;
31414 wxWindow *arg1 = (wxWindow *) 0 ;
31415 void *argp1 = 0 ;
31416 int res1 = 0 ;
31417 PyObject *swig_obj[1] ;
31418
31419 if (!args) SWIG_fail;
31420 swig_obj[0] = args;
31421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31422 if (!SWIG_IsOK(res1)) {
31423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31424 }
31425 arg1 = reinterpret_cast< wxWindow * >(argp1);
31426 {
31427 PyThreadState* __tstate = wxPyBeginAllowThreads();
31428 (arg1)->FitInside();
31429 wxPyEndAllowThreads(__tstate);
31430 if (PyErr_Occurred()) SWIG_fail;
31431 }
31432 resultobj = SWIG_Py_Void();
31433 return resultobj;
31434 fail:
31435 return NULL;
31436 }
31437
31438
31439 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31440 PyObject *resultobj = 0;
31441 wxWindow *arg1 = (wxWindow *) 0 ;
31442 int arg2 ;
31443 int arg3 ;
31444 int arg4 = (int) -1 ;
31445 int arg5 = (int) -1 ;
31446 int arg6 = (int) -1 ;
31447 int arg7 = (int) -1 ;
31448 void *argp1 = 0 ;
31449 int res1 = 0 ;
31450 int val2 ;
31451 int ecode2 = 0 ;
31452 int val3 ;
31453 int ecode3 = 0 ;
31454 int val4 ;
31455 int ecode4 = 0 ;
31456 int val5 ;
31457 int ecode5 = 0 ;
31458 int val6 ;
31459 int ecode6 = 0 ;
31460 int val7 ;
31461 int ecode7 = 0 ;
31462 PyObject * obj0 = 0 ;
31463 PyObject * obj1 = 0 ;
31464 PyObject * obj2 = 0 ;
31465 PyObject * obj3 = 0 ;
31466 PyObject * obj4 = 0 ;
31467 PyObject * obj5 = 0 ;
31468 PyObject * obj6 = 0 ;
31469 char * kwnames[] = {
31470 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31471 };
31472
31473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31475 if (!SWIG_IsOK(res1)) {
31476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31477 }
31478 arg1 = reinterpret_cast< wxWindow * >(argp1);
31479 ecode2 = SWIG_AsVal_int(obj1, &val2);
31480 if (!SWIG_IsOK(ecode2)) {
31481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31482 }
31483 arg2 = static_cast< int >(val2);
31484 ecode3 = SWIG_AsVal_int(obj2, &val3);
31485 if (!SWIG_IsOK(ecode3)) {
31486 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31487 }
31488 arg3 = static_cast< int >(val3);
31489 if (obj3) {
31490 ecode4 = SWIG_AsVal_int(obj3, &val4);
31491 if (!SWIG_IsOK(ecode4)) {
31492 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31493 }
31494 arg4 = static_cast< int >(val4);
31495 }
31496 if (obj4) {
31497 ecode5 = SWIG_AsVal_int(obj4, &val5);
31498 if (!SWIG_IsOK(ecode5)) {
31499 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31500 }
31501 arg5 = static_cast< int >(val5);
31502 }
31503 if (obj5) {
31504 ecode6 = SWIG_AsVal_int(obj5, &val6);
31505 if (!SWIG_IsOK(ecode6)) {
31506 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31507 }
31508 arg6 = static_cast< int >(val6);
31509 }
31510 if (obj6) {
31511 ecode7 = SWIG_AsVal_int(obj6, &val7);
31512 if (!SWIG_IsOK(ecode7)) {
31513 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31514 }
31515 arg7 = static_cast< int >(val7);
31516 }
31517 {
31518 PyThreadState* __tstate = wxPyBeginAllowThreads();
31519 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31520 wxPyEndAllowThreads(__tstate);
31521 if (PyErr_Occurred()) SWIG_fail;
31522 }
31523 resultobj = SWIG_Py_Void();
31524 return resultobj;
31525 fail:
31526 return NULL;
31527 }
31528
31529
31530 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31531 PyObject *resultobj = 0;
31532 wxWindow *arg1 = (wxWindow *) 0 ;
31533 wxSize *arg2 = 0 ;
31534 wxSize const &arg3_defvalue = wxDefaultSize ;
31535 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31536 wxSize const &arg4_defvalue = wxDefaultSize ;
31537 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31538 void *argp1 = 0 ;
31539 int res1 = 0 ;
31540 wxSize temp2 ;
31541 wxSize temp3 ;
31542 wxSize temp4 ;
31543 PyObject * obj0 = 0 ;
31544 PyObject * obj1 = 0 ;
31545 PyObject * obj2 = 0 ;
31546 PyObject * obj3 = 0 ;
31547 char * kwnames[] = {
31548 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31549 };
31550
31551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31553 if (!SWIG_IsOK(res1)) {
31554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31555 }
31556 arg1 = reinterpret_cast< wxWindow * >(argp1);
31557 {
31558 arg2 = &temp2;
31559 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31560 }
31561 if (obj2) {
31562 {
31563 arg3 = &temp3;
31564 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31565 }
31566 }
31567 if (obj3) {
31568 {
31569 arg4 = &temp4;
31570 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31571 }
31572 }
31573 {
31574 PyThreadState* __tstate = wxPyBeginAllowThreads();
31575 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31576 wxPyEndAllowThreads(__tstate);
31577 if (PyErr_Occurred()) SWIG_fail;
31578 }
31579 resultobj = SWIG_Py_Void();
31580 return resultobj;
31581 fail:
31582 return NULL;
31583 }
31584
31585
31586 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31587 PyObject *resultobj = 0;
31588 wxWindow *arg1 = (wxWindow *) 0 ;
31589 int arg2 ;
31590 int arg3 ;
31591 int arg4 = (int) -1 ;
31592 int arg5 = (int) -1 ;
31593 void *argp1 = 0 ;
31594 int res1 = 0 ;
31595 int val2 ;
31596 int ecode2 = 0 ;
31597 int val3 ;
31598 int ecode3 = 0 ;
31599 int val4 ;
31600 int ecode4 = 0 ;
31601 int val5 ;
31602 int ecode5 = 0 ;
31603 PyObject * obj0 = 0 ;
31604 PyObject * obj1 = 0 ;
31605 PyObject * obj2 = 0 ;
31606 PyObject * obj3 = 0 ;
31607 PyObject * obj4 = 0 ;
31608 char * kwnames[] = {
31609 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31610 };
31611
31612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31614 if (!SWIG_IsOK(res1)) {
31615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31616 }
31617 arg1 = reinterpret_cast< wxWindow * >(argp1);
31618 ecode2 = SWIG_AsVal_int(obj1, &val2);
31619 if (!SWIG_IsOK(ecode2)) {
31620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31621 }
31622 arg2 = static_cast< int >(val2);
31623 ecode3 = SWIG_AsVal_int(obj2, &val3);
31624 if (!SWIG_IsOK(ecode3)) {
31625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31626 }
31627 arg3 = static_cast< int >(val3);
31628 if (obj3) {
31629 ecode4 = SWIG_AsVal_int(obj3, &val4);
31630 if (!SWIG_IsOK(ecode4)) {
31631 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31632 }
31633 arg4 = static_cast< int >(val4);
31634 }
31635 if (obj4) {
31636 ecode5 = SWIG_AsVal_int(obj4, &val5);
31637 if (!SWIG_IsOK(ecode5)) {
31638 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31639 }
31640 arg5 = static_cast< int >(val5);
31641 }
31642 {
31643 PyThreadState* __tstate = wxPyBeginAllowThreads();
31644 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31645 wxPyEndAllowThreads(__tstate);
31646 if (PyErr_Occurred()) SWIG_fail;
31647 }
31648 resultobj = SWIG_Py_Void();
31649 return resultobj;
31650 fail:
31651 return NULL;
31652 }
31653
31654
31655 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31656 PyObject *resultobj = 0;
31657 wxWindow *arg1 = (wxWindow *) 0 ;
31658 wxSize *arg2 = 0 ;
31659 wxSize const &arg3_defvalue = wxDefaultSize ;
31660 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31661 void *argp1 = 0 ;
31662 int res1 = 0 ;
31663 wxSize temp2 ;
31664 wxSize temp3 ;
31665 PyObject * obj0 = 0 ;
31666 PyObject * obj1 = 0 ;
31667 PyObject * obj2 = 0 ;
31668 char * kwnames[] = {
31669 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31670 };
31671
31672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31674 if (!SWIG_IsOK(res1)) {
31675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31676 }
31677 arg1 = reinterpret_cast< wxWindow * >(argp1);
31678 {
31679 arg2 = &temp2;
31680 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31681 }
31682 if (obj2) {
31683 {
31684 arg3 = &temp3;
31685 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31686 }
31687 }
31688 {
31689 PyThreadState* __tstate = wxPyBeginAllowThreads();
31690 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31691 wxPyEndAllowThreads(__tstate);
31692 if (PyErr_Occurred()) SWIG_fail;
31693 }
31694 resultobj = SWIG_Py_Void();
31695 return resultobj;
31696 fail:
31697 return NULL;
31698 }
31699
31700
31701 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31702 PyObject *resultobj = 0;
31703 wxWindow *arg1 = (wxWindow *) 0 ;
31704 wxSize result;
31705 void *argp1 = 0 ;
31706 int res1 = 0 ;
31707 PyObject *swig_obj[1] ;
31708
31709 if (!args) SWIG_fail;
31710 swig_obj[0] = args;
31711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31712 if (!SWIG_IsOK(res1)) {
31713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31714 }
31715 arg1 = reinterpret_cast< wxWindow * >(argp1);
31716 {
31717 PyThreadState* __tstate = wxPyBeginAllowThreads();
31718 result = ((wxWindow const *)arg1)->GetMaxSize();
31719 wxPyEndAllowThreads(__tstate);
31720 if (PyErr_Occurred()) SWIG_fail;
31721 }
31722 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31723 return resultobj;
31724 fail:
31725 return NULL;
31726 }
31727
31728
31729 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31730 PyObject *resultobj = 0;
31731 wxWindow *arg1 = (wxWindow *) 0 ;
31732 wxSize result;
31733 void *argp1 = 0 ;
31734 int res1 = 0 ;
31735 PyObject *swig_obj[1] ;
31736
31737 if (!args) SWIG_fail;
31738 swig_obj[0] = args;
31739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31740 if (!SWIG_IsOK(res1)) {
31741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31742 }
31743 arg1 = reinterpret_cast< wxWindow * >(argp1);
31744 {
31745 PyThreadState* __tstate = wxPyBeginAllowThreads();
31746 result = ((wxWindow const *)arg1)->GetMinSize();
31747 wxPyEndAllowThreads(__tstate);
31748 if (PyErr_Occurred()) SWIG_fail;
31749 }
31750 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31751 return resultobj;
31752 fail:
31753 return NULL;
31754 }
31755
31756
31757 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31758 PyObject *resultobj = 0;
31759 wxWindow *arg1 = (wxWindow *) 0 ;
31760 wxSize *arg2 = 0 ;
31761 void *argp1 = 0 ;
31762 int res1 = 0 ;
31763 wxSize temp2 ;
31764 PyObject * obj0 = 0 ;
31765 PyObject * obj1 = 0 ;
31766 char * kwnames[] = {
31767 (char *) "self",(char *) "minSize", NULL
31768 };
31769
31770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31772 if (!SWIG_IsOK(res1)) {
31773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31774 }
31775 arg1 = reinterpret_cast< wxWindow * >(argp1);
31776 {
31777 arg2 = &temp2;
31778 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31779 }
31780 {
31781 PyThreadState* __tstate = wxPyBeginAllowThreads();
31782 (arg1)->SetMinSize((wxSize const &)*arg2);
31783 wxPyEndAllowThreads(__tstate);
31784 if (PyErr_Occurred()) SWIG_fail;
31785 }
31786 resultobj = SWIG_Py_Void();
31787 return resultobj;
31788 fail:
31789 return NULL;
31790 }
31791
31792
31793 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31794 PyObject *resultobj = 0;
31795 wxWindow *arg1 = (wxWindow *) 0 ;
31796 wxSize *arg2 = 0 ;
31797 void *argp1 = 0 ;
31798 int res1 = 0 ;
31799 wxSize temp2 ;
31800 PyObject * obj0 = 0 ;
31801 PyObject * obj1 = 0 ;
31802 char * kwnames[] = {
31803 (char *) "self",(char *) "maxSize", NULL
31804 };
31805
31806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31808 if (!SWIG_IsOK(res1)) {
31809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31810 }
31811 arg1 = reinterpret_cast< wxWindow * >(argp1);
31812 {
31813 arg2 = &temp2;
31814 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31815 }
31816 {
31817 PyThreadState* __tstate = wxPyBeginAllowThreads();
31818 (arg1)->SetMaxSize((wxSize const &)*arg2);
31819 wxPyEndAllowThreads(__tstate);
31820 if (PyErr_Occurred()) SWIG_fail;
31821 }
31822 resultobj = SWIG_Py_Void();
31823 return resultobj;
31824 fail:
31825 return NULL;
31826 }
31827
31828
31829 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31830 PyObject *resultobj = 0;
31831 wxWindow *arg1 = (wxWindow *) 0 ;
31832 int result;
31833 void *argp1 = 0 ;
31834 int res1 = 0 ;
31835 PyObject *swig_obj[1] ;
31836
31837 if (!args) SWIG_fail;
31838 swig_obj[0] = args;
31839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31840 if (!SWIG_IsOK(res1)) {
31841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31842 }
31843 arg1 = reinterpret_cast< wxWindow * >(argp1);
31844 {
31845 PyThreadState* __tstate = wxPyBeginAllowThreads();
31846 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31847 wxPyEndAllowThreads(__tstate);
31848 if (PyErr_Occurred()) SWIG_fail;
31849 }
31850 resultobj = SWIG_From_int(static_cast< int >(result));
31851 return resultobj;
31852 fail:
31853 return NULL;
31854 }
31855
31856
31857 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31858 PyObject *resultobj = 0;
31859 wxWindow *arg1 = (wxWindow *) 0 ;
31860 int result;
31861 void *argp1 = 0 ;
31862 int res1 = 0 ;
31863 PyObject *swig_obj[1] ;
31864
31865 if (!args) SWIG_fail;
31866 swig_obj[0] = args;
31867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31868 if (!SWIG_IsOK(res1)) {
31869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31870 }
31871 arg1 = reinterpret_cast< wxWindow * >(argp1);
31872 {
31873 PyThreadState* __tstate = wxPyBeginAllowThreads();
31874 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31875 wxPyEndAllowThreads(__tstate);
31876 if (PyErr_Occurred()) SWIG_fail;
31877 }
31878 resultobj = SWIG_From_int(static_cast< int >(result));
31879 return resultobj;
31880 fail:
31881 return NULL;
31882 }
31883
31884
31885 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31886 PyObject *resultobj = 0;
31887 wxWindow *arg1 = (wxWindow *) 0 ;
31888 int result;
31889 void *argp1 = 0 ;
31890 int res1 = 0 ;
31891 PyObject *swig_obj[1] ;
31892
31893 if (!args) SWIG_fail;
31894 swig_obj[0] = args;
31895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31896 if (!SWIG_IsOK(res1)) {
31897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31898 }
31899 arg1 = reinterpret_cast< wxWindow * >(argp1);
31900 {
31901 PyThreadState* __tstate = wxPyBeginAllowThreads();
31902 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31903 wxPyEndAllowThreads(__tstate);
31904 if (PyErr_Occurred()) SWIG_fail;
31905 }
31906 resultobj = SWIG_From_int(static_cast< int >(result));
31907 return resultobj;
31908 fail:
31909 return NULL;
31910 }
31911
31912
31913 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31914 PyObject *resultobj = 0;
31915 wxWindow *arg1 = (wxWindow *) 0 ;
31916 int result;
31917 void *argp1 = 0 ;
31918 int res1 = 0 ;
31919 PyObject *swig_obj[1] ;
31920
31921 if (!args) SWIG_fail;
31922 swig_obj[0] = args;
31923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31924 if (!SWIG_IsOK(res1)) {
31925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31926 }
31927 arg1 = reinterpret_cast< wxWindow * >(argp1);
31928 {
31929 PyThreadState* __tstate = wxPyBeginAllowThreads();
31930 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31931 wxPyEndAllowThreads(__tstate);
31932 if (PyErr_Occurred()) SWIG_fail;
31933 }
31934 resultobj = SWIG_From_int(static_cast< int >(result));
31935 return resultobj;
31936 fail:
31937 return NULL;
31938 }
31939
31940
31941 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31942 PyObject *resultobj = 0;
31943 wxWindow *arg1 = (wxWindow *) 0 ;
31944 wxSize *arg2 = 0 ;
31945 void *argp1 = 0 ;
31946 int res1 = 0 ;
31947 wxSize temp2 ;
31948 PyObject * obj0 = 0 ;
31949 PyObject * obj1 = 0 ;
31950 char * kwnames[] = {
31951 (char *) "self",(char *) "size", NULL
31952 };
31953
31954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31956 if (!SWIG_IsOK(res1)) {
31957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31958 }
31959 arg1 = reinterpret_cast< wxWindow * >(argp1);
31960 {
31961 arg2 = &temp2;
31962 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31963 }
31964 {
31965 PyThreadState* __tstate = wxPyBeginAllowThreads();
31966 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31967 wxPyEndAllowThreads(__tstate);
31968 if (PyErr_Occurred()) SWIG_fail;
31969 }
31970 resultobj = SWIG_Py_Void();
31971 return resultobj;
31972 fail:
31973 return NULL;
31974 }
31975
31976
31977 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31978 PyObject *resultobj = 0;
31979 wxWindow *arg1 = (wxWindow *) 0 ;
31980 int arg2 ;
31981 int arg3 ;
31982 void *argp1 = 0 ;
31983 int res1 = 0 ;
31984 int val2 ;
31985 int ecode2 = 0 ;
31986 int val3 ;
31987 int ecode3 = 0 ;
31988 PyObject * obj0 = 0 ;
31989 PyObject * obj1 = 0 ;
31990 PyObject * obj2 = 0 ;
31991 char * kwnames[] = {
31992 (char *) "self",(char *) "w",(char *) "h", NULL
31993 };
31994
31995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31997 if (!SWIG_IsOK(res1)) {
31998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31999 }
32000 arg1 = reinterpret_cast< wxWindow * >(argp1);
32001 ecode2 = SWIG_AsVal_int(obj1, &val2);
32002 if (!SWIG_IsOK(ecode2)) {
32003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32004 }
32005 arg2 = static_cast< int >(val2);
32006 ecode3 = SWIG_AsVal_int(obj2, &val3);
32007 if (!SWIG_IsOK(ecode3)) {
32008 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32009 }
32010 arg3 = static_cast< int >(val3);
32011 {
32012 PyThreadState* __tstate = wxPyBeginAllowThreads();
32013 (arg1)->SetVirtualSize(arg2,arg3);
32014 wxPyEndAllowThreads(__tstate);
32015 if (PyErr_Occurred()) SWIG_fail;
32016 }
32017 resultobj = SWIG_Py_Void();
32018 return resultobj;
32019 fail:
32020 return NULL;
32021 }
32022
32023
32024 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32025 PyObject *resultobj = 0;
32026 wxWindow *arg1 = (wxWindow *) 0 ;
32027 wxSize result;
32028 void *argp1 = 0 ;
32029 int res1 = 0 ;
32030 PyObject *swig_obj[1] ;
32031
32032 if (!args) SWIG_fail;
32033 swig_obj[0] = args;
32034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32035 if (!SWIG_IsOK(res1)) {
32036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32037 }
32038 arg1 = reinterpret_cast< wxWindow * >(argp1);
32039 {
32040 PyThreadState* __tstate = wxPyBeginAllowThreads();
32041 result = ((wxWindow const *)arg1)->GetVirtualSize();
32042 wxPyEndAllowThreads(__tstate);
32043 if (PyErr_Occurred()) SWIG_fail;
32044 }
32045 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32046 return resultobj;
32047 fail:
32048 return NULL;
32049 }
32050
32051
32052 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32053 PyObject *resultobj = 0;
32054 wxWindow *arg1 = (wxWindow *) 0 ;
32055 int *arg2 = (int *) 0 ;
32056 int *arg3 = (int *) 0 ;
32057 void *argp1 = 0 ;
32058 int res1 = 0 ;
32059 int temp2 ;
32060 int res2 = SWIG_TMPOBJ ;
32061 int temp3 ;
32062 int res3 = SWIG_TMPOBJ ;
32063 PyObject *swig_obj[1] ;
32064
32065 arg2 = &temp2;
32066 arg3 = &temp3;
32067 if (!args) SWIG_fail;
32068 swig_obj[0] = args;
32069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32070 if (!SWIG_IsOK(res1)) {
32071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32072 }
32073 arg1 = reinterpret_cast< wxWindow * >(argp1);
32074 {
32075 PyThreadState* __tstate = wxPyBeginAllowThreads();
32076 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32077 wxPyEndAllowThreads(__tstate);
32078 if (PyErr_Occurred()) SWIG_fail;
32079 }
32080 resultobj = SWIG_Py_Void();
32081 if (SWIG_IsTmpObj(res2)) {
32082 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32083 } else {
32084 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32085 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32086 }
32087 if (SWIG_IsTmpObj(res3)) {
32088 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32089 } else {
32090 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32091 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32092 }
32093 return resultobj;
32094 fail:
32095 return NULL;
32096 }
32097
32098
32099 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32100 PyObject *resultobj = 0;
32101 wxWindow *arg1 = (wxWindow *) 0 ;
32102 wxSize result;
32103 void *argp1 = 0 ;
32104 int res1 = 0 ;
32105 PyObject *swig_obj[1] ;
32106
32107 if (!args) SWIG_fail;
32108 swig_obj[0] = args;
32109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32110 if (!SWIG_IsOK(res1)) {
32111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32112 }
32113 arg1 = reinterpret_cast< wxWindow * >(argp1);
32114 {
32115 PyThreadState* __tstate = wxPyBeginAllowThreads();
32116 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32117 wxPyEndAllowThreads(__tstate);
32118 if (PyErr_Occurred()) SWIG_fail;
32119 }
32120 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32121 return resultobj;
32122 fail:
32123 return NULL;
32124 }
32125
32126
32127 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32128 PyObject *resultobj = 0;
32129 wxWindow *arg1 = (wxWindow *) 0 ;
32130 bool arg2 = (bool) true ;
32131 bool result;
32132 void *argp1 = 0 ;
32133 int res1 = 0 ;
32134 bool val2 ;
32135 int ecode2 = 0 ;
32136 PyObject * obj0 = 0 ;
32137 PyObject * obj1 = 0 ;
32138 char * kwnames[] = {
32139 (char *) "self",(char *) "show", NULL
32140 };
32141
32142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32144 if (!SWIG_IsOK(res1)) {
32145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32146 }
32147 arg1 = reinterpret_cast< wxWindow * >(argp1);
32148 if (obj1) {
32149 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32150 if (!SWIG_IsOK(ecode2)) {
32151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32152 }
32153 arg2 = static_cast< bool >(val2);
32154 }
32155 {
32156 PyThreadState* __tstate = wxPyBeginAllowThreads();
32157 result = (bool)(arg1)->Show(arg2);
32158 wxPyEndAllowThreads(__tstate);
32159 if (PyErr_Occurred()) SWIG_fail;
32160 }
32161 {
32162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32163 }
32164 return resultobj;
32165 fail:
32166 return NULL;
32167 }
32168
32169
32170 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32171 PyObject *resultobj = 0;
32172 wxWindow *arg1 = (wxWindow *) 0 ;
32173 bool result;
32174 void *argp1 = 0 ;
32175 int res1 = 0 ;
32176 PyObject *swig_obj[1] ;
32177
32178 if (!args) SWIG_fail;
32179 swig_obj[0] = args;
32180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32181 if (!SWIG_IsOK(res1)) {
32182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32183 }
32184 arg1 = reinterpret_cast< wxWindow * >(argp1);
32185 {
32186 PyThreadState* __tstate = wxPyBeginAllowThreads();
32187 result = (bool)(arg1)->Hide();
32188 wxPyEndAllowThreads(__tstate);
32189 if (PyErr_Occurred()) SWIG_fail;
32190 }
32191 {
32192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32193 }
32194 return resultobj;
32195 fail:
32196 return NULL;
32197 }
32198
32199
32200 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32201 PyObject *resultobj = 0;
32202 wxWindow *arg1 = (wxWindow *) 0 ;
32203 bool arg2 = (bool) true ;
32204 bool result;
32205 void *argp1 = 0 ;
32206 int res1 = 0 ;
32207 bool val2 ;
32208 int ecode2 = 0 ;
32209 PyObject * obj0 = 0 ;
32210 PyObject * obj1 = 0 ;
32211 char * kwnames[] = {
32212 (char *) "self",(char *) "enable", NULL
32213 };
32214
32215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32217 if (!SWIG_IsOK(res1)) {
32218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32219 }
32220 arg1 = reinterpret_cast< wxWindow * >(argp1);
32221 if (obj1) {
32222 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32223 if (!SWIG_IsOK(ecode2)) {
32224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32225 }
32226 arg2 = static_cast< bool >(val2);
32227 }
32228 {
32229 PyThreadState* __tstate = wxPyBeginAllowThreads();
32230 result = (bool)(arg1)->Enable(arg2);
32231 wxPyEndAllowThreads(__tstate);
32232 if (PyErr_Occurred()) SWIG_fail;
32233 }
32234 {
32235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32236 }
32237 return resultobj;
32238 fail:
32239 return NULL;
32240 }
32241
32242
32243 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32244 PyObject *resultobj = 0;
32245 wxWindow *arg1 = (wxWindow *) 0 ;
32246 bool result;
32247 void *argp1 = 0 ;
32248 int res1 = 0 ;
32249 PyObject *swig_obj[1] ;
32250
32251 if (!args) SWIG_fail;
32252 swig_obj[0] = args;
32253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32254 if (!SWIG_IsOK(res1)) {
32255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32256 }
32257 arg1 = reinterpret_cast< wxWindow * >(argp1);
32258 {
32259 PyThreadState* __tstate = wxPyBeginAllowThreads();
32260 result = (bool)(arg1)->Disable();
32261 wxPyEndAllowThreads(__tstate);
32262 if (PyErr_Occurred()) SWIG_fail;
32263 }
32264 {
32265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32266 }
32267 return resultobj;
32268 fail:
32269 return NULL;
32270 }
32271
32272
32273 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32274 PyObject *resultobj = 0;
32275 wxWindow *arg1 = (wxWindow *) 0 ;
32276 bool result;
32277 void *argp1 = 0 ;
32278 int res1 = 0 ;
32279 PyObject *swig_obj[1] ;
32280
32281 if (!args) SWIG_fail;
32282 swig_obj[0] = args;
32283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32284 if (!SWIG_IsOK(res1)) {
32285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32286 }
32287 arg1 = reinterpret_cast< wxWindow * >(argp1);
32288 {
32289 PyThreadState* __tstate = wxPyBeginAllowThreads();
32290 result = (bool)((wxWindow const *)arg1)->IsShown();
32291 wxPyEndAllowThreads(__tstate);
32292 if (PyErr_Occurred()) SWIG_fail;
32293 }
32294 {
32295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32296 }
32297 return resultobj;
32298 fail:
32299 return NULL;
32300 }
32301
32302
32303 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32304 PyObject *resultobj = 0;
32305 wxWindow *arg1 = (wxWindow *) 0 ;
32306 bool result;
32307 void *argp1 = 0 ;
32308 int res1 = 0 ;
32309 PyObject *swig_obj[1] ;
32310
32311 if (!args) SWIG_fail;
32312 swig_obj[0] = args;
32313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32314 if (!SWIG_IsOK(res1)) {
32315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32316 }
32317 arg1 = reinterpret_cast< wxWindow * >(argp1);
32318 {
32319 PyThreadState* __tstate = wxPyBeginAllowThreads();
32320 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32321 wxPyEndAllowThreads(__tstate);
32322 if (PyErr_Occurred()) SWIG_fail;
32323 }
32324 {
32325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32326 }
32327 return resultobj;
32328 fail:
32329 return NULL;
32330 }
32331
32332
32333 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32334 PyObject *resultobj = 0;
32335 wxWindow *arg1 = (wxWindow *) 0 ;
32336 long arg2 ;
32337 void *argp1 = 0 ;
32338 int res1 = 0 ;
32339 long val2 ;
32340 int ecode2 = 0 ;
32341 PyObject * obj0 = 0 ;
32342 PyObject * obj1 = 0 ;
32343 char * kwnames[] = {
32344 (char *) "self",(char *) "style", NULL
32345 };
32346
32347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32349 if (!SWIG_IsOK(res1)) {
32350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32351 }
32352 arg1 = reinterpret_cast< wxWindow * >(argp1);
32353 ecode2 = SWIG_AsVal_long(obj1, &val2);
32354 if (!SWIG_IsOK(ecode2)) {
32355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32356 }
32357 arg2 = static_cast< long >(val2);
32358 {
32359 PyThreadState* __tstate = wxPyBeginAllowThreads();
32360 (arg1)->SetWindowStyleFlag(arg2);
32361 wxPyEndAllowThreads(__tstate);
32362 if (PyErr_Occurred()) SWIG_fail;
32363 }
32364 resultobj = SWIG_Py_Void();
32365 return resultobj;
32366 fail:
32367 return NULL;
32368 }
32369
32370
32371 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32372 PyObject *resultobj = 0;
32373 wxWindow *arg1 = (wxWindow *) 0 ;
32374 long result;
32375 void *argp1 = 0 ;
32376 int res1 = 0 ;
32377 PyObject *swig_obj[1] ;
32378
32379 if (!args) SWIG_fail;
32380 swig_obj[0] = args;
32381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32382 if (!SWIG_IsOK(res1)) {
32383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32384 }
32385 arg1 = reinterpret_cast< wxWindow * >(argp1);
32386 {
32387 PyThreadState* __tstate = wxPyBeginAllowThreads();
32388 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32389 wxPyEndAllowThreads(__tstate);
32390 if (PyErr_Occurred()) SWIG_fail;
32391 }
32392 resultobj = SWIG_From_long(static_cast< long >(result));
32393 return resultobj;
32394 fail:
32395 return NULL;
32396 }
32397
32398
32399 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32400 PyObject *resultobj = 0;
32401 wxWindow *arg1 = (wxWindow *) 0 ;
32402 int arg2 ;
32403 bool result;
32404 void *argp1 = 0 ;
32405 int res1 = 0 ;
32406 int val2 ;
32407 int ecode2 = 0 ;
32408 PyObject * obj0 = 0 ;
32409 PyObject * obj1 = 0 ;
32410 char * kwnames[] = {
32411 (char *) "self",(char *) "flag", NULL
32412 };
32413
32414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32416 if (!SWIG_IsOK(res1)) {
32417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32418 }
32419 arg1 = reinterpret_cast< wxWindow * >(argp1);
32420 ecode2 = SWIG_AsVal_int(obj1, &val2);
32421 if (!SWIG_IsOK(ecode2)) {
32422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32423 }
32424 arg2 = static_cast< int >(val2);
32425 {
32426 PyThreadState* __tstate = wxPyBeginAllowThreads();
32427 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32428 wxPyEndAllowThreads(__tstate);
32429 if (PyErr_Occurred()) SWIG_fail;
32430 }
32431 {
32432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32433 }
32434 return resultobj;
32435 fail:
32436 return NULL;
32437 }
32438
32439
32440 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32441 PyObject *resultobj = 0;
32442 wxWindow *arg1 = (wxWindow *) 0 ;
32443 bool result;
32444 void *argp1 = 0 ;
32445 int res1 = 0 ;
32446 PyObject *swig_obj[1] ;
32447
32448 if (!args) SWIG_fail;
32449 swig_obj[0] = args;
32450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32451 if (!SWIG_IsOK(res1)) {
32452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32453 }
32454 arg1 = reinterpret_cast< wxWindow * >(argp1);
32455 {
32456 PyThreadState* __tstate = wxPyBeginAllowThreads();
32457 result = (bool)((wxWindow const *)arg1)->IsRetained();
32458 wxPyEndAllowThreads(__tstate);
32459 if (PyErr_Occurred()) SWIG_fail;
32460 }
32461 {
32462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32463 }
32464 return resultobj;
32465 fail:
32466 return NULL;
32467 }
32468
32469
32470 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32471 PyObject *resultobj = 0;
32472 wxWindow *arg1 = (wxWindow *) 0 ;
32473 long arg2 ;
32474 void *argp1 = 0 ;
32475 int res1 = 0 ;
32476 long val2 ;
32477 int ecode2 = 0 ;
32478 PyObject * obj0 = 0 ;
32479 PyObject * obj1 = 0 ;
32480 char * kwnames[] = {
32481 (char *) "self",(char *) "exStyle", NULL
32482 };
32483
32484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",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_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32488 }
32489 arg1 = reinterpret_cast< wxWindow * >(argp1);
32490 ecode2 = SWIG_AsVal_long(obj1, &val2);
32491 if (!SWIG_IsOK(ecode2)) {
32492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32493 }
32494 arg2 = static_cast< long >(val2);
32495 {
32496 PyThreadState* __tstate = wxPyBeginAllowThreads();
32497 (arg1)->SetExtraStyle(arg2);
32498 wxPyEndAllowThreads(__tstate);
32499 if (PyErr_Occurred()) SWIG_fail;
32500 }
32501 resultobj = SWIG_Py_Void();
32502 return resultobj;
32503 fail:
32504 return NULL;
32505 }
32506
32507
32508 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32509 PyObject *resultobj = 0;
32510 wxWindow *arg1 = (wxWindow *) 0 ;
32511 long result;
32512 void *argp1 = 0 ;
32513 int res1 = 0 ;
32514 PyObject *swig_obj[1] ;
32515
32516 if (!args) SWIG_fail;
32517 swig_obj[0] = args;
32518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32519 if (!SWIG_IsOK(res1)) {
32520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32521 }
32522 arg1 = reinterpret_cast< wxWindow * >(argp1);
32523 {
32524 PyThreadState* __tstate = wxPyBeginAllowThreads();
32525 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32526 wxPyEndAllowThreads(__tstate);
32527 if (PyErr_Occurred()) SWIG_fail;
32528 }
32529 resultobj = SWIG_From_long(static_cast< long >(result));
32530 return resultobj;
32531 fail:
32532 return NULL;
32533 }
32534
32535
32536 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32537 PyObject *resultobj = 0;
32538 wxWindow *arg1 = (wxWindow *) 0 ;
32539 bool arg2 = (bool) true ;
32540 void *argp1 = 0 ;
32541 int res1 = 0 ;
32542 bool val2 ;
32543 int ecode2 = 0 ;
32544 PyObject * obj0 = 0 ;
32545 PyObject * obj1 = 0 ;
32546 char * kwnames[] = {
32547 (char *) "self",(char *) "modal", NULL
32548 };
32549
32550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32552 if (!SWIG_IsOK(res1)) {
32553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32554 }
32555 arg1 = reinterpret_cast< wxWindow * >(argp1);
32556 if (obj1) {
32557 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32558 if (!SWIG_IsOK(ecode2)) {
32559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32560 }
32561 arg2 = static_cast< bool >(val2);
32562 }
32563 {
32564 PyThreadState* __tstate = wxPyBeginAllowThreads();
32565 (arg1)->MakeModal(arg2);
32566 wxPyEndAllowThreads(__tstate);
32567 if (PyErr_Occurred()) SWIG_fail;
32568 }
32569 resultobj = SWIG_Py_Void();
32570 return resultobj;
32571 fail:
32572 return NULL;
32573 }
32574
32575
32576 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32577 PyObject *resultobj = 0;
32578 wxWindow *arg1 = (wxWindow *) 0 ;
32579 bool arg2 ;
32580 void *argp1 = 0 ;
32581 int res1 = 0 ;
32582 bool val2 ;
32583 int ecode2 = 0 ;
32584 PyObject * obj0 = 0 ;
32585 PyObject * obj1 = 0 ;
32586 char * kwnames[] = {
32587 (char *) "self",(char *) "enableTheme", NULL
32588 };
32589
32590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32592 if (!SWIG_IsOK(res1)) {
32593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32594 }
32595 arg1 = reinterpret_cast< wxWindow * >(argp1);
32596 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32597 if (!SWIG_IsOK(ecode2)) {
32598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32599 }
32600 arg2 = static_cast< bool >(val2);
32601 {
32602 PyThreadState* __tstate = wxPyBeginAllowThreads();
32603 (arg1)->SetThemeEnabled(arg2);
32604 wxPyEndAllowThreads(__tstate);
32605 if (PyErr_Occurred()) SWIG_fail;
32606 }
32607 resultobj = SWIG_Py_Void();
32608 return resultobj;
32609 fail:
32610 return NULL;
32611 }
32612
32613
32614 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32615 PyObject *resultobj = 0;
32616 wxWindow *arg1 = (wxWindow *) 0 ;
32617 bool result;
32618 void *argp1 = 0 ;
32619 int res1 = 0 ;
32620 PyObject *swig_obj[1] ;
32621
32622 if (!args) SWIG_fail;
32623 swig_obj[0] = args;
32624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32625 if (!SWIG_IsOK(res1)) {
32626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32627 }
32628 arg1 = reinterpret_cast< wxWindow * >(argp1);
32629 {
32630 PyThreadState* __tstate = wxPyBeginAllowThreads();
32631 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32632 wxPyEndAllowThreads(__tstate);
32633 if (PyErr_Occurred()) SWIG_fail;
32634 }
32635 {
32636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32637 }
32638 return resultobj;
32639 fail:
32640 return NULL;
32641 }
32642
32643
32644 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32645 PyObject *resultobj = 0;
32646 wxWindow *arg1 = (wxWindow *) 0 ;
32647 void *argp1 = 0 ;
32648 int res1 = 0 ;
32649 PyObject *swig_obj[1] ;
32650
32651 if (!args) SWIG_fail;
32652 swig_obj[0] = args;
32653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32654 if (!SWIG_IsOK(res1)) {
32655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32656 }
32657 arg1 = reinterpret_cast< wxWindow * >(argp1);
32658 {
32659 PyThreadState* __tstate = wxPyBeginAllowThreads();
32660 (arg1)->SetFocus();
32661 wxPyEndAllowThreads(__tstate);
32662 if (PyErr_Occurred()) SWIG_fail;
32663 }
32664 resultobj = SWIG_Py_Void();
32665 return resultobj;
32666 fail:
32667 return NULL;
32668 }
32669
32670
32671 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32672 PyObject *resultobj = 0;
32673 wxWindow *arg1 = (wxWindow *) 0 ;
32674 void *argp1 = 0 ;
32675 int res1 = 0 ;
32676 PyObject *swig_obj[1] ;
32677
32678 if (!args) SWIG_fail;
32679 swig_obj[0] = args;
32680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32681 if (!SWIG_IsOK(res1)) {
32682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32683 }
32684 arg1 = reinterpret_cast< wxWindow * >(argp1);
32685 {
32686 PyThreadState* __tstate = wxPyBeginAllowThreads();
32687 (arg1)->SetFocusFromKbd();
32688 wxPyEndAllowThreads(__tstate);
32689 if (PyErr_Occurred()) SWIG_fail;
32690 }
32691 resultobj = SWIG_Py_Void();
32692 return resultobj;
32693 fail:
32694 return NULL;
32695 }
32696
32697
32698 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32699 PyObject *resultobj = 0;
32700 wxWindow *result = 0 ;
32701
32702 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32703 {
32704 if (!wxPyCheckForApp()) SWIG_fail;
32705 PyThreadState* __tstate = wxPyBeginAllowThreads();
32706 result = (wxWindow *)wxWindow::FindFocus();
32707 wxPyEndAllowThreads(__tstate);
32708 if (PyErr_Occurred()) SWIG_fail;
32709 }
32710 {
32711 resultobj = wxPyMake_wxObject(result, 0);
32712 }
32713 return resultobj;
32714 fail:
32715 return NULL;
32716 }
32717
32718
32719 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32720 PyObject *resultobj = 0;
32721 wxWindow *arg1 = (wxWindow *) 0 ;
32722 bool result;
32723 void *argp1 = 0 ;
32724 int res1 = 0 ;
32725 PyObject *swig_obj[1] ;
32726
32727 if (!args) SWIG_fail;
32728 swig_obj[0] = args;
32729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32730 if (!SWIG_IsOK(res1)) {
32731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32732 }
32733 arg1 = reinterpret_cast< wxWindow * >(argp1);
32734 {
32735 PyThreadState* __tstate = wxPyBeginAllowThreads();
32736 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32737 wxPyEndAllowThreads(__tstate);
32738 if (PyErr_Occurred()) SWIG_fail;
32739 }
32740 {
32741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32742 }
32743 return resultobj;
32744 fail:
32745 return NULL;
32746 }
32747
32748
32749 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32750 PyObject *resultobj = 0;
32751 wxWindow *arg1 = (wxWindow *) 0 ;
32752 bool result;
32753 void *argp1 = 0 ;
32754 int res1 = 0 ;
32755 PyObject *swig_obj[1] ;
32756
32757 if (!args) SWIG_fail;
32758 swig_obj[0] = args;
32759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32760 if (!SWIG_IsOK(res1)) {
32761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32762 }
32763 arg1 = reinterpret_cast< wxWindow * >(argp1);
32764 {
32765 PyThreadState* __tstate = wxPyBeginAllowThreads();
32766 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32767 wxPyEndAllowThreads(__tstate);
32768 if (PyErr_Occurred()) SWIG_fail;
32769 }
32770 {
32771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32772 }
32773 return resultobj;
32774 fail:
32775 return NULL;
32776 }
32777
32778
32779 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32780 PyObject *resultobj = 0;
32781 wxWindow *arg1 = (wxWindow *) 0 ;
32782 wxWindow *result = 0 ;
32783 void *argp1 = 0 ;
32784 int res1 = 0 ;
32785 PyObject *swig_obj[1] ;
32786
32787 if (!args) SWIG_fail;
32788 swig_obj[0] = args;
32789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32790 if (!SWIG_IsOK(res1)) {
32791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32792 }
32793 arg1 = reinterpret_cast< wxWindow * >(argp1);
32794 {
32795 PyThreadState* __tstate = wxPyBeginAllowThreads();
32796 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32797 wxPyEndAllowThreads(__tstate);
32798 if (PyErr_Occurred()) SWIG_fail;
32799 }
32800 {
32801 resultobj = wxPyMake_wxObject(result, 0);
32802 }
32803 return resultobj;
32804 fail:
32805 return NULL;
32806 }
32807
32808
32809 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32810 PyObject *resultobj = 0;
32811 wxWindow *arg1 = (wxWindow *) 0 ;
32812 wxWindow *arg2 = (wxWindow *) 0 ;
32813 wxWindow *result = 0 ;
32814 void *argp1 = 0 ;
32815 int res1 = 0 ;
32816 void *argp2 = 0 ;
32817 int res2 = 0 ;
32818 PyObject * obj0 = 0 ;
32819 PyObject * obj1 = 0 ;
32820 char * kwnames[] = {
32821 (char *) "self",(char *) "child", NULL
32822 };
32823
32824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32826 if (!SWIG_IsOK(res1)) {
32827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32828 }
32829 arg1 = reinterpret_cast< wxWindow * >(argp1);
32830 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32831 if (!SWIG_IsOK(res2)) {
32832 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32833 }
32834 arg2 = reinterpret_cast< wxWindow * >(argp2);
32835 {
32836 PyThreadState* __tstate = wxPyBeginAllowThreads();
32837 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32838 wxPyEndAllowThreads(__tstate);
32839 if (PyErr_Occurred()) SWIG_fail;
32840 }
32841 {
32842 resultobj = wxPyMake_wxObject(result, 0);
32843 }
32844 return resultobj;
32845 fail:
32846 return NULL;
32847 }
32848
32849
32850 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32851 PyObject *resultobj = 0;
32852 wxWindow *arg1 = (wxWindow *) 0 ;
32853 wxWindow *arg2 = (wxWindow *) 0 ;
32854 void *argp1 = 0 ;
32855 int res1 = 0 ;
32856 void *argp2 = 0 ;
32857 int res2 = 0 ;
32858 PyObject * obj0 = 0 ;
32859 PyObject * obj1 = 0 ;
32860 char * kwnames[] = {
32861 (char *) "self",(char *) "win", NULL
32862 };
32863
32864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32866 if (!SWIG_IsOK(res1)) {
32867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32868 }
32869 arg1 = reinterpret_cast< wxWindow * >(argp1);
32870 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32871 if (!SWIG_IsOK(res2)) {
32872 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32873 }
32874 arg2 = reinterpret_cast< wxWindow * >(argp2);
32875 {
32876 PyThreadState* __tstate = wxPyBeginAllowThreads();
32877 (arg1)->SetTmpDefaultItem(arg2);
32878 wxPyEndAllowThreads(__tstate);
32879 if (PyErr_Occurred()) SWIG_fail;
32880 }
32881 resultobj = SWIG_Py_Void();
32882 return resultobj;
32883 fail:
32884 return NULL;
32885 }
32886
32887
32888 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32889 PyObject *resultobj = 0;
32890 wxWindow *arg1 = (wxWindow *) 0 ;
32891 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32892 bool result;
32893 void *argp1 = 0 ;
32894 int res1 = 0 ;
32895 int val2 ;
32896 int ecode2 = 0 ;
32897 PyObject * obj0 = 0 ;
32898 PyObject * obj1 = 0 ;
32899 char * kwnames[] = {
32900 (char *) "self",(char *) "flags", NULL
32901 };
32902
32903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32905 if (!SWIG_IsOK(res1)) {
32906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32907 }
32908 arg1 = reinterpret_cast< wxWindow * >(argp1);
32909 if (obj1) {
32910 ecode2 = SWIG_AsVal_int(obj1, &val2);
32911 if (!SWIG_IsOK(ecode2)) {
32912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32913 }
32914 arg2 = static_cast< int >(val2);
32915 }
32916 {
32917 PyThreadState* __tstate = wxPyBeginAllowThreads();
32918 result = (bool)(arg1)->Navigate(arg2);
32919 wxPyEndAllowThreads(__tstate);
32920 if (PyErr_Occurred()) SWIG_fail;
32921 }
32922 {
32923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32924 }
32925 return resultobj;
32926 fail:
32927 return NULL;
32928 }
32929
32930
32931 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32932 PyObject *resultobj = 0;
32933 wxWindow *arg1 = (wxWindow *) 0 ;
32934 wxWindow *arg2 = (wxWindow *) 0 ;
32935 void *argp1 = 0 ;
32936 int res1 = 0 ;
32937 void *argp2 = 0 ;
32938 int res2 = 0 ;
32939 PyObject * obj0 = 0 ;
32940 PyObject * obj1 = 0 ;
32941 char * kwnames[] = {
32942 (char *) "self",(char *) "win", NULL
32943 };
32944
32945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32947 if (!SWIG_IsOK(res1)) {
32948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32949 }
32950 arg1 = reinterpret_cast< wxWindow * >(argp1);
32951 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32952 if (!SWIG_IsOK(res2)) {
32953 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32954 }
32955 arg2 = reinterpret_cast< wxWindow * >(argp2);
32956 {
32957 PyThreadState* __tstate = wxPyBeginAllowThreads();
32958 (arg1)->MoveAfterInTabOrder(arg2);
32959 wxPyEndAllowThreads(__tstate);
32960 if (PyErr_Occurred()) SWIG_fail;
32961 }
32962 resultobj = SWIG_Py_Void();
32963 return resultobj;
32964 fail:
32965 return NULL;
32966 }
32967
32968
32969 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32970 PyObject *resultobj = 0;
32971 wxWindow *arg1 = (wxWindow *) 0 ;
32972 wxWindow *arg2 = (wxWindow *) 0 ;
32973 void *argp1 = 0 ;
32974 int res1 = 0 ;
32975 void *argp2 = 0 ;
32976 int res2 = 0 ;
32977 PyObject * obj0 = 0 ;
32978 PyObject * obj1 = 0 ;
32979 char * kwnames[] = {
32980 (char *) "self",(char *) "win", NULL
32981 };
32982
32983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32985 if (!SWIG_IsOK(res1)) {
32986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32987 }
32988 arg1 = reinterpret_cast< wxWindow * >(argp1);
32989 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32990 if (!SWIG_IsOK(res2)) {
32991 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32992 }
32993 arg2 = reinterpret_cast< wxWindow * >(argp2);
32994 {
32995 PyThreadState* __tstate = wxPyBeginAllowThreads();
32996 (arg1)->MoveBeforeInTabOrder(arg2);
32997 wxPyEndAllowThreads(__tstate);
32998 if (PyErr_Occurred()) SWIG_fail;
32999 }
33000 resultobj = SWIG_Py_Void();
33001 return resultobj;
33002 fail:
33003 return NULL;
33004 }
33005
33006
33007 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33008 PyObject *resultobj = 0;
33009 wxWindow *arg1 = (wxWindow *) 0 ;
33010 PyObject *result = 0 ;
33011 void *argp1 = 0 ;
33012 int res1 = 0 ;
33013 PyObject *swig_obj[1] ;
33014
33015 if (!args) SWIG_fail;
33016 swig_obj[0] = args;
33017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33018 if (!SWIG_IsOK(res1)) {
33019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33020 }
33021 arg1 = reinterpret_cast< wxWindow * >(argp1);
33022 {
33023 PyThreadState* __tstate = wxPyBeginAllowThreads();
33024 result = (PyObject *)wxWindow_GetChildren(arg1);
33025 wxPyEndAllowThreads(__tstate);
33026 if (PyErr_Occurred()) SWIG_fail;
33027 }
33028 resultobj = result;
33029 return resultobj;
33030 fail:
33031 return NULL;
33032 }
33033
33034
33035 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33036 PyObject *resultobj = 0;
33037 wxWindow *arg1 = (wxWindow *) 0 ;
33038 wxWindow *result = 0 ;
33039 void *argp1 = 0 ;
33040 int res1 = 0 ;
33041 PyObject *swig_obj[1] ;
33042
33043 if (!args) SWIG_fail;
33044 swig_obj[0] = args;
33045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33046 if (!SWIG_IsOK(res1)) {
33047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33048 }
33049 arg1 = reinterpret_cast< wxWindow * >(argp1);
33050 {
33051 PyThreadState* __tstate = wxPyBeginAllowThreads();
33052 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33053 wxPyEndAllowThreads(__tstate);
33054 if (PyErr_Occurred()) SWIG_fail;
33055 }
33056 {
33057 resultobj = wxPyMake_wxObject(result, 0);
33058 }
33059 return resultobj;
33060 fail:
33061 return NULL;
33062 }
33063
33064
33065 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33066 PyObject *resultobj = 0;
33067 wxWindow *arg1 = (wxWindow *) 0 ;
33068 wxWindow *result = 0 ;
33069 void *argp1 = 0 ;
33070 int res1 = 0 ;
33071 PyObject *swig_obj[1] ;
33072
33073 if (!args) SWIG_fail;
33074 swig_obj[0] = args;
33075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33076 if (!SWIG_IsOK(res1)) {
33077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33078 }
33079 arg1 = reinterpret_cast< wxWindow * >(argp1);
33080 {
33081 PyThreadState* __tstate = wxPyBeginAllowThreads();
33082 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33083 wxPyEndAllowThreads(__tstate);
33084 if (PyErr_Occurred()) SWIG_fail;
33085 }
33086 {
33087 resultobj = wxPyMake_wxObject(result, 0);
33088 }
33089 return resultobj;
33090 fail:
33091 return NULL;
33092 }
33093
33094
33095 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33096 PyObject *resultobj = 0;
33097 wxWindow *arg1 = (wxWindow *) 0 ;
33098 bool result;
33099 void *argp1 = 0 ;
33100 int res1 = 0 ;
33101 PyObject *swig_obj[1] ;
33102
33103 if (!args) SWIG_fail;
33104 swig_obj[0] = args;
33105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33106 if (!SWIG_IsOK(res1)) {
33107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33108 }
33109 arg1 = reinterpret_cast< wxWindow * >(argp1);
33110 {
33111 PyThreadState* __tstate = wxPyBeginAllowThreads();
33112 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33113 wxPyEndAllowThreads(__tstate);
33114 if (PyErr_Occurred()) SWIG_fail;
33115 }
33116 {
33117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33118 }
33119 return resultobj;
33120 fail:
33121 return NULL;
33122 }
33123
33124
33125 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33126 PyObject *resultobj = 0;
33127 wxWindow *arg1 = (wxWindow *) 0 ;
33128 wxWindow *arg2 = (wxWindow *) 0 ;
33129 bool result;
33130 void *argp1 = 0 ;
33131 int res1 = 0 ;
33132 void *argp2 = 0 ;
33133 int res2 = 0 ;
33134 PyObject * obj0 = 0 ;
33135 PyObject * obj1 = 0 ;
33136 char * kwnames[] = {
33137 (char *) "self",(char *) "newParent", NULL
33138 };
33139
33140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33142 if (!SWIG_IsOK(res1)) {
33143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33144 }
33145 arg1 = reinterpret_cast< wxWindow * >(argp1);
33146 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33147 if (!SWIG_IsOK(res2)) {
33148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33149 }
33150 arg2 = reinterpret_cast< wxWindow * >(argp2);
33151 {
33152 PyThreadState* __tstate = wxPyBeginAllowThreads();
33153 result = (bool)(arg1)->Reparent(arg2);
33154 wxPyEndAllowThreads(__tstate);
33155 if (PyErr_Occurred()) SWIG_fail;
33156 }
33157 {
33158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33159 }
33160 return resultobj;
33161 fail:
33162 return NULL;
33163 }
33164
33165
33166 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33167 PyObject *resultobj = 0;
33168 wxWindow *arg1 = (wxWindow *) 0 ;
33169 wxWindow *arg2 = (wxWindow *) 0 ;
33170 void *argp1 = 0 ;
33171 int res1 = 0 ;
33172 void *argp2 = 0 ;
33173 int res2 = 0 ;
33174 PyObject * obj0 = 0 ;
33175 PyObject * obj1 = 0 ;
33176 char * kwnames[] = {
33177 (char *) "self",(char *) "child", NULL
33178 };
33179
33180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33182 if (!SWIG_IsOK(res1)) {
33183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33184 }
33185 arg1 = reinterpret_cast< wxWindow * >(argp1);
33186 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33187 if (!SWIG_IsOK(res2)) {
33188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33189 }
33190 arg2 = reinterpret_cast< wxWindow * >(argp2);
33191 {
33192 PyThreadState* __tstate = wxPyBeginAllowThreads();
33193 (arg1)->AddChild(arg2);
33194 wxPyEndAllowThreads(__tstate);
33195 if (PyErr_Occurred()) SWIG_fail;
33196 }
33197 resultobj = SWIG_Py_Void();
33198 return resultobj;
33199 fail:
33200 return NULL;
33201 }
33202
33203
33204 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33205 PyObject *resultobj = 0;
33206 wxWindow *arg1 = (wxWindow *) 0 ;
33207 wxWindow *arg2 = (wxWindow *) 0 ;
33208 void *argp1 = 0 ;
33209 int res1 = 0 ;
33210 void *argp2 = 0 ;
33211 int res2 = 0 ;
33212 PyObject * obj0 = 0 ;
33213 PyObject * obj1 = 0 ;
33214 char * kwnames[] = {
33215 (char *) "self",(char *) "child", NULL
33216 };
33217
33218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33220 if (!SWIG_IsOK(res1)) {
33221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33222 }
33223 arg1 = reinterpret_cast< wxWindow * >(argp1);
33224 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33225 if (!SWIG_IsOK(res2)) {
33226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33227 }
33228 arg2 = reinterpret_cast< wxWindow * >(argp2);
33229 {
33230 PyThreadState* __tstate = wxPyBeginAllowThreads();
33231 (arg1)->RemoveChild(arg2);
33232 wxPyEndAllowThreads(__tstate);
33233 if (PyErr_Occurred()) SWIG_fail;
33234 }
33235 resultobj = SWIG_Py_Void();
33236 return resultobj;
33237 fail:
33238 return NULL;
33239 }
33240
33241
33242 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33243 PyObject *resultobj = 0;
33244 wxWindow *arg1 = (wxWindow *) 0 ;
33245 bool arg2 ;
33246 void *argp1 = 0 ;
33247 int res1 = 0 ;
33248 bool val2 ;
33249 int ecode2 = 0 ;
33250 PyObject * obj0 = 0 ;
33251 PyObject * obj1 = 0 ;
33252 char * kwnames[] = {
33253 (char *) "self",(char *) "on", NULL
33254 };
33255
33256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33258 if (!SWIG_IsOK(res1)) {
33259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33260 }
33261 arg1 = reinterpret_cast< wxWindow * >(argp1);
33262 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33263 if (!SWIG_IsOK(ecode2)) {
33264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33265 }
33266 arg2 = static_cast< bool >(val2);
33267 {
33268 PyThreadState* __tstate = wxPyBeginAllowThreads();
33269 wxWindow_SetDoubleBuffered(arg1,arg2);
33270 wxPyEndAllowThreads(__tstate);
33271 if (PyErr_Occurred()) SWIG_fail;
33272 }
33273 resultobj = SWIG_Py_Void();
33274 return resultobj;
33275 fail:
33276 return NULL;
33277 }
33278
33279
33280 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33281 PyObject *resultobj = 0;
33282 wxWindow *arg1 = (wxWindow *) 0 ;
33283 long arg2 ;
33284 wxWindow *result = 0 ;
33285 void *argp1 = 0 ;
33286 int res1 = 0 ;
33287 long val2 ;
33288 int ecode2 = 0 ;
33289 PyObject * obj0 = 0 ;
33290 PyObject * obj1 = 0 ;
33291 char * kwnames[] = {
33292 (char *) "self",(char *) "winid", NULL
33293 };
33294
33295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33297 if (!SWIG_IsOK(res1)) {
33298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33299 }
33300 arg1 = reinterpret_cast< wxWindow * >(argp1);
33301 ecode2 = SWIG_AsVal_long(obj1, &val2);
33302 if (!SWIG_IsOK(ecode2)) {
33303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33304 }
33305 arg2 = static_cast< long >(val2);
33306 {
33307 PyThreadState* __tstate = wxPyBeginAllowThreads();
33308 result = (wxWindow *)(arg1)->FindWindow(arg2);
33309 wxPyEndAllowThreads(__tstate);
33310 if (PyErr_Occurred()) SWIG_fail;
33311 }
33312 {
33313 resultobj = wxPyMake_wxObject(result, 0);
33314 }
33315 return resultobj;
33316 fail:
33317 return NULL;
33318 }
33319
33320
33321 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33322 PyObject *resultobj = 0;
33323 wxWindow *arg1 = (wxWindow *) 0 ;
33324 wxString *arg2 = 0 ;
33325 wxWindow *result = 0 ;
33326 void *argp1 = 0 ;
33327 int res1 = 0 ;
33328 bool temp2 = false ;
33329 PyObject * obj0 = 0 ;
33330 PyObject * obj1 = 0 ;
33331 char * kwnames[] = {
33332 (char *) "self",(char *) "name", NULL
33333 };
33334
33335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33337 if (!SWIG_IsOK(res1)) {
33338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33339 }
33340 arg1 = reinterpret_cast< wxWindow * >(argp1);
33341 {
33342 arg2 = wxString_in_helper(obj1);
33343 if (arg2 == NULL) SWIG_fail;
33344 temp2 = true;
33345 }
33346 {
33347 PyThreadState* __tstate = wxPyBeginAllowThreads();
33348 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33349 wxPyEndAllowThreads(__tstate);
33350 if (PyErr_Occurred()) SWIG_fail;
33351 }
33352 {
33353 resultobj = wxPyMake_wxObject(result, 0);
33354 }
33355 {
33356 if (temp2)
33357 delete arg2;
33358 }
33359 return resultobj;
33360 fail:
33361 {
33362 if (temp2)
33363 delete arg2;
33364 }
33365 return NULL;
33366 }
33367
33368
33369 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33370 PyObject *resultobj = 0;
33371 wxWindow *arg1 = (wxWindow *) 0 ;
33372 wxEvtHandler *result = 0 ;
33373 void *argp1 = 0 ;
33374 int res1 = 0 ;
33375 PyObject *swig_obj[1] ;
33376
33377 if (!args) SWIG_fail;
33378 swig_obj[0] = args;
33379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33380 if (!SWIG_IsOK(res1)) {
33381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33382 }
33383 arg1 = reinterpret_cast< wxWindow * >(argp1);
33384 {
33385 PyThreadState* __tstate = wxPyBeginAllowThreads();
33386 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33387 wxPyEndAllowThreads(__tstate);
33388 if (PyErr_Occurred()) SWIG_fail;
33389 }
33390 {
33391 resultobj = wxPyMake_wxObject(result, 0);
33392 }
33393 return resultobj;
33394 fail:
33395 return NULL;
33396 }
33397
33398
33399 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33400 PyObject *resultobj = 0;
33401 wxWindow *arg1 = (wxWindow *) 0 ;
33402 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33403 void *argp1 = 0 ;
33404 int res1 = 0 ;
33405 void *argp2 = 0 ;
33406 int res2 = 0 ;
33407 PyObject * obj0 = 0 ;
33408 PyObject * obj1 = 0 ;
33409 char * kwnames[] = {
33410 (char *) "self",(char *) "handler", NULL
33411 };
33412
33413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33415 if (!SWIG_IsOK(res1)) {
33416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33417 }
33418 arg1 = reinterpret_cast< wxWindow * >(argp1);
33419 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33420 if (!SWIG_IsOK(res2)) {
33421 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33422 }
33423 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33424 {
33425 PyThreadState* __tstate = wxPyBeginAllowThreads();
33426 (arg1)->SetEventHandler(arg2);
33427 wxPyEndAllowThreads(__tstate);
33428 if (PyErr_Occurred()) SWIG_fail;
33429 }
33430 resultobj = SWIG_Py_Void();
33431 return resultobj;
33432 fail:
33433 return NULL;
33434 }
33435
33436
33437 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33438 PyObject *resultobj = 0;
33439 wxWindow *arg1 = (wxWindow *) 0 ;
33440 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33441 void *argp1 = 0 ;
33442 int res1 = 0 ;
33443 void *argp2 = 0 ;
33444 int res2 = 0 ;
33445 PyObject * obj0 = 0 ;
33446 PyObject * obj1 = 0 ;
33447 char * kwnames[] = {
33448 (char *) "self",(char *) "handler", NULL
33449 };
33450
33451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33453 if (!SWIG_IsOK(res1)) {
33454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33455 }
33456 arg1 = reinterpret_cast< wxWindow * >(argp1);
33457 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33458 if (!SWIG_IsOK(res2)) {
33459 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33460 }
33461 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33462 {
33463 PyThreadState* __tstate = wxPyBeginAllowThreads();
33464 (arg1)->PushEventHandler(arg2);
33465 wxPyEndAllowThreads(__tstate);
33466 if (PyErr_Occurred()) SWIG_fail;
33467 }
33468 resultobj = SWIG_Py_Void();
33469 return resultobj;
33470 fail:
33471 return NULL;
33472 }
33473
33474
33475 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33476 PyObject *resultobj = 0;
33477 wxWindow *arg1 = (wxWindow *) 0 ;
33478 bool arg2 = (bool) false ;
33479 wxEvtHandler *result = 0 ;
33480 void *argp1 = 0 ;
33481 int res1 = 0 ;
33482 bool val2 ;
33483 int ecode2 = 0 ;
33484 PyObject * obj0 = 0 ;
33485 PyObject * obj1 = 0 ;
33486 char * kwnames[] = {
33487 (char *) "self",(char *) "deleteHandler", NULL
33488 };
33489
33490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33492 if (!SWIG_IsOK(res1)) {
33493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33494 }
33495 arg1 = reinterpret_cast< wxWindow * >(argp1);
33496 if (obj1) {
33497 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33498 if (!SWIG_IsOK(ecode2)) {
33499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33500 }
33501 arg2 = static_cast< bool >(val2);
33502 }
33503 {
33504 PyThreadState* __tstate = wxPyBeginAllowThreads();
33505 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33506 wxPyEndAllowThreads(__tstate);
33507 if (PyErr_Occurred()) SWIG_fail;
33508 }
33509 {
33510 resultobj = wxPyMake_wxObject(result, 0);
33511 }
33512 return resultobj;
33513 fail:
33514 return NULL;
33515 }
33516
33517
33518 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33519 PyObject *resultobj = 0;
33520 wxWindow *arg1 = (wxWindow *) 0 ;
33521 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33522 bool result;
33523 void *argp1 = 0 ;
33524 int res1 = 0 ;
33525 void *argp2 = 0 ;
33526 int res2 = 0 ;
33527 PyObject * obj0 = 0 ;
33528 PyObject * obj1 = 0 ;
33529 char * kwnames[] = {
33530 (char *) "self",(char *) "handler", NULL
33531 };
33532
33533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33535 if (!SWIG_IsOK(res1)) {
33536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33537 }
33538 arg1 = reinterpret_cast< wxWindow * >(argp1);
33539 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33540 if (!SWIG_IsOK(res2)) {
33541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33542 }
33543 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33544 {
33545 PyThreadState* __tstate = wxPyBeginAllowThreads();
33546 result = (bool)(arg1)->RemoveEventHandler(arg2);
33547 wxPyEndAllowThreads(__tstate);
33548 if (PyErr_Occurred()) SWIG_fail;
33549 }
33550 {
33551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33552 }
33553 return resultobj;
33554 fail:
33555 return NULL;
33556 }
33557
33558
33559 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33560 PyObject *resultobj = 0;
33561 wxWindow *arg1 = (wxWindow *) 0 ;
33562 wxValidator *arg2 = 0 ;
33563 void *argp1 = 0 ;
33564 int res1 = 0 ;
33565 void *argp2 = 0 ;
33566 int res2 = 0 ;
33567 PyObject * obj0 = 0 ;
33568 PyObject * obj1 = 0 ;
33569 char * kwnames[] = {
33570 (char *) "self",(char *) "validator", NULL
33571 };
33572
33573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33575 if (!SWIG_IsOK(res1)) {
33576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33577 }
33578 arg1 = reinterpret_cast< wxWindow * >(argp1);
33579 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33580 if (!SWIG_IsOK(res2)) {
33581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33582 }
33583 if (!argp2) {
33584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33585 }
33586 arg2 = reinterpret_cast< wxValidator * >(argp2);
33587 {
33588 PyThreadState* __tstate = wxPyBeginAllowThreads();
33589 (arg1)->SetValidator((wxValidator const &)*arg2);
33590 wxPyEndAllowThreads(__tstate);
33591 if (PyErr_Occurred()) SWIG_fail;
33592 }
33593 resultobj = SWIG_Py_Void();
33594 return resultobj;
33595 fail:
33596 return NULL;
33597 }
33598
33599
33600 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33601 PyObject *resultobj = 0;
33602 wxWindow *arg1 = (wxWindow *) 0 ;
33603 wxValidator *result = 0 ;
33604 void *argp1 = 0 ;
33605 int res1 = 0 ;
33606 PyObject *swig_obj[1] ;
33607
33608 if (!args) SWIG_fail;
33609 swig_obj[0] = args;
33610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33611 if (!SWIG_IsOK(res1)) {
33612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33613 }
33614 arg1 = reinterpret_cast< wxWindow * >(argp1);
33615 {
33616 PyThreadState* __tstate = wxPyBeginAllowThreads();
33617 result = (wxValidator *)(arg1)->GetValidator();
33618 wxPyEndAllowThreads(__tstate);
33619 if (PyErr_Occurred()) SWIG_fail;
33620 }
33621 {
33622 resultobj = wxPyMake_wxObject(result, (bool)0);
33623 }
33624 return resultobj;
33625 fail:
33626 return NULL;
33627 }
33628
33629
33630 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33631 PyObject *resultobj = 0;
33632 wxWindow *arg1 = (wxWindow *) 0 ;
33633 bool result;
33634 void *argp1 = 0 ;
33635 int res1 = 0 ;
33636 PyObject *swig_obj[1] ;
33637
33638 if (!args) SWIG_fail;
33639 swig_obj[0] = args;
33640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33641 if (!SWIG_IsOK(res1)) {
33642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33643 }
33644 arg1 = reinterpret_cast< wxWindow * >(argp1);
33645 {
33646 PyThreadState* __tstate = wxPyBeginAllowThreads();
33647 result = (bool)(arg1)->Validate();
33648 wxPyEndAllowThreads(__tstate);
33649 if (PyErr_Occurred()) SWIG_fail;
33650 }
33651 {
33652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33653 }
33654 return resultobj;
33655 fail:
33656 return NULL;
33657 }
33658
33659
33660 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33661 PyObject *resultobj = 0;
33662 wxWindow *arg1 = (wxWindow *) 0 ;
33663 bool result;
33664 void *argp1 = 0 ;
33665 int res1 = 0 ;
33666 PyObject *swig_obj[1] ;
33667
33668 if (!args) SWIG_fail;
33669 swig_obj[0] = args;
33670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33671 if (!SWIG_IsOK(res1)) {
33672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33673 }
33674 arg1 = reinterpret_cast< wxWindow * >(argp1);
33675 {
33676 PyThreadState* __tstate = wxPyBeginAllowThreads();
33677 result = (bool)(arg1)->TransferDataToWindow();
33678 wxPyEndAllowThreads(__tstate);
33679 if (PyErr_Occurred()) SWIG_fail;
33680 }
33681 {
33682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33683 }
33684 return resultobj;
33685 fail:
33686 return NULL;
33687 }
33688
33689
33690 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33691 PyObject *resultobj = 0;
33692 wxWindow *arg1 = (wxWindow *) 0 ;
33693 bool result;
33694 void *argp1 = 0 ;
33695 int res1 = 0 ;
33696 PyObject *swig_obj[1] ;
33697
33698 if (!args) SWIG_fail;
33699 swig_obj[0] = args;
33700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33701 if (!SWIG_IsOK(res1)) {
33702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33703 }
33704 arg1 = reinterpret_cast< wxWindow * >(argp1);
33705 {
33706 PyThreadState* __tstate = wxPyBeginAllowThreads();
33707 result = (bool)(arg1)->TransferDataFromWindow();
33708 wxPyEndAllowThreads(__tstate);
33709 if (PyErr_Occurred()) SWIG_fail;
33710 }
33711 {
33712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33713 }
33714 return resultobj;
33715 fail:
33716 return NULL;
33717 }
33718
33719
33720 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33721 PyObject *resultobj = 0;
33722 wxWindow *arg1 = (wxWindow *) 0 ;
33723 void *argp1 = 0 ;
33724 int res1 = 0 ;
33725 PyObject *swig_obj[1] ;
33726
33727 if (!args) SWIG_fail;
33728 swig_obj[0] = args;
33729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33730 if (!SWIG_IsOK(res1)) {
33731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33732 }
33733 arg1 = reinterpret_cast< wxWindow * >(argp1);
33734 {
33735 PyThreadState* __tstate = wxPyBeginAllowThreads();
33736 (arg1)->InitDialog();
33737 wxPyEndAllowThreads(__tstate);
33738 if (PyErr_Occurred()) SWIG_fail;
33739 }
33740 resultobj = SWIG_Py_Void();
33741 return resultobj;
33742 fail:
33743 return NULL;
33744 }
33745
33746
33747 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33748 PyObject *resultobj = 0;
33749 wxWindow *arg1 = (wxWindow *) 0 ;
33750 wxAcceleratorTable *arg2 = 0 ;
33751 void *argp1 = 0 ;
33752 int res1 = 0 ;
33753 void *argp2 = 0 ;
33754 int res2 = 0 ;
33755 PyObject * obj0 = 0 ;
33756 PyObject * obj1 = 0 ;
33757 char * kwnames[] = {
33758 (char *) "self",(char *) "accel", NULL
33759 };
33760
33761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33763 if (!SWIG_IsOK(res1)) {
33764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33765 }
33766 arg1 = reinterpret_cast< wxWindow * >(argp1);
33767 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33768 if (!SWIG_IsOK(res2)) {
33769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33770 }
33771 if (!argp2) {
33772 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33773 }
33774 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33775 {
33776 PyThreadState* __tstate = wxPyBeginAllowThreads();
33777 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33778 wxPyEndAllowThreads(__tstate);
33779 if (PyErr_Occurred()) SWIG_fail;
33780 }
33781 resultobj = SWIG_Py_Void();
33782 return resultobj;
33783 fail:
33784 return NULL;
33785 }
33786
33787
33788 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33789 PyObject *resultobj = 0;
33790 wxWindow *arg1 = (wxWindow *) 0 ;
33791 wxAcceleratorTable *result = 0 ;
33792 void *argp1 = 0 ;
33793 int res1 = 0 ;
33794 PyObject *swig_obj[1] ;
33795
33796 if (!args) SWIG_fail;
33797 swig_obj[0] = args;
33798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33799 if (!SWIG_IsOK(res1)) {
33800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33801 }
33802 arg1 = reinterpret_cast< wxWindow * >(argp1);
33803 {
33804 PyThreadState* __tstate = wxPyBeginAllowThreads();
33805 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33806 wxPyEndAllowThreads(__tstate);
33807 if (PyErr_Occurred()) SWIG_fail;
33808 }
33809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33810 return resultobj;
33811 fail:
33812 return NULL;
33813 }
33814
33815
33816 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33817 PyObject *resultobj = 0;
33818 wxWindow *arg1 = (wxWindow *) 0 ;
33819 int arg2 ;
33820 int arg3 ;
33821 int arg4 ;
33822 bool result;
33823 void *argp1 = 0 ;
33824 int res1 = 0 ;
33825 int val2 ;
33826 int ecode2 = 0 ;
33827 int val3 ;
33828 int ecode3 = 0 ;
33829 int val4 ;
33830 int ecode4 = 0 ;
33831 PyObject * obj0 = 0 ;
33832 PyObject * obj1 = 0 ;
33833 PyObject * obj2 = 0 ;
33834 PyObject * obj3 = 0 ;
33835 char * kwnames[] = {
33836 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33837 };
33838
33839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33841 if (!SWIG_IsOK(res1)) {
33842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33843 }
33844 arg1 = reinterpret_cast< wxWindow * >(argp1);
33845 ecode2 = SWIG_AsVal_int(obj1, &val2);
33846 if (!SWIG_IsOK(ecode2)) {
33847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33848 }
33849 arg2 = static_cast< int >(val2);
33850 ecode3 = SWIG_AsVal_int(obj2, &val3);
33851 if (!SWIG_IsOK(ecode3)) {
33852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33853 }
33854 arg3 = static_cast< int >(val3);
33855 ecode4 = SWIG_AsVal_int(obj3, &val4);
33856 if (!SWIG_IsOK(ecode4)) {
33857 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33858 }
33859 arg4 = static_cast< int >(val4);
33860 {
33861 PyThreadState* __tstate = wxPyBeginAllowThreads();
33862 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33863 wxPyEndAllowThreads(__tstate);
33864 if (PyErr_Occurred()) SWIG_fail;
33865 }
33866 {
33867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33868 }
33869 return resultobj;
33870 fail:
33871 return NULL;
33872 }
33873
33874
33875 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33876 PyObject *resultobj = 0;
33877 wxWindow *arg1 = (wxWindow *) 0 ;
33878 int arg2 ;
33879 bool result;
33880 void *argp1 = 0 ;
33881 int res1 = 0 ;
33882 int val2 ;
33883 int ecode2 = 0 ;
33884 PyObject * obj0 = 0 ;
33885 PyObject * obj1 = 0 ;
33886 char * kwnames[] = {
33887 (char *) "self",(char *) "hotkeyId", NULL
33888 };
33889
33890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33892 if (!SWIG_IsOK(res1)) {
33893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33894 }
33895 arg1 = reinterpret_cast< wxWindow * >(argp1);
33896 ecode2 = SWIG_AsVal_int(obj1, &val2);
33897 if (!SWIG_IsOK(ecode2)) {
33898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33899 }
33900 arg2 = static_cast< int >(val2);
33901 {
33902 PyThreadState* __tstate = wxPyBeginAllowThreads();
33903 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33904 wxPyEndAllowThreads(__tstate);
33905 if (PyErr_Occurred()) SWIG_fail;
33906 }
33907 {
33908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33909 }
33910 return resultobj;
33911 fail:
33912 return NULL;
33913 }
33914
33915
33916 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33917 PyObject *resultobj = 0;
33918 wxWindow *arg1 = (wxWindow *) 0 ;
33919 wxPoint *arg2 = 0 ;
33920 wxPoint result;
33921 void *argp1 = 0 ;
33922 int res1 = 0 ;
33923 wxPoint temp2 ;
33924 PyObject * obj0 = 0 ;
33925 PyObject * obj1 = 0 ;
33926 char * kwnames[] = {
33927 (char *) "self",(char *) "pt", NULL
33928 };
33929
33930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33932 if (!SWIG_IsOK(res1)) {
33933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33934 }
33935 arg1 = reinterpret_cast< wxWindow * >(argp1);
33936 {
33937 arg2 = &temp2;
33938 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33939 }
33940 {
33941 PyThreadState* __tstate = wxPyBeginAllowThreads();
33942 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33943 wxPyEndAllowThreads(__tstate);
33944 if (PyErr_Occurred()) SWIG_fail;
33945 }
33946 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33947 return resultobj;
33948 fail:
33949 return NULL;
33950 }
33951
33952
33953 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33954 PyObject *resultobj = 0;
33955 wxWindow *arg1 = (wxWindow *) 0 ;
33956 wxSize *arg2 = 0 ;
33957 wxSize result;
33958 void *argp1 = 0 ;
33959 int res1 = 0 ;
33960 wxSize temp2 ;
33961 PyObject * obj0 = 0 ;
33962 PyObject * obj1 = 0 ;
33963 char * kwnames[] = {
33964 (char *) "self",(char *) "sz", NULL
33965 };
33966
33967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33969 if (!SWIG_IsOK(res1)) {
33970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33971 }
33972 arg1 = reinterpret_cast< wxWindow * >(argp1);
33973 {
33974 arg2 = &temp2;
33975 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33976 }
33977 {
33978 PyThreadState* __tstate = wxPyBeginAllowThreads();
33979 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33980 wxPyEndAllowThreads(__tstate);
33981 if (PyErr_Occurred()) SWIG_fail;
33982 }
33983 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33984 return resultobj;
33985 fail:
33986 return NULL;
33987 }
33988
33989
33990 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33991 PyObject *resultobj = 0;
33992 wxWindow *arg1 = (wxWindow *) 0 ;
33993 wxPoint *arg2 = 0 ;
33994 wxPoint result;
33995 void *argp1 = 0 ;
33996 int res1 = 0 ;
33997 wxPoint temp2 ;
33998 PyObject * obj0 = 0 ;
33999 PyObject * obj1 = 0 ;
34000 char * kwnames[] = {
34001 (char *) "self",(char *) "pt", NULL
34002 };
34003
34004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34006 if (!SWIG_IsOK(res1)) {
34007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34008 }
34009 arg1 = reinterpret_cast< wxWindow * >(argp1);
34010 {
34011 arg2 = &temp2;
34012 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34013 }
34014 {
34015 PyThreadState* __tstate = wxPyBeginAllowThreads();
34016 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34017 wxPyEndAllowThreads(__tstate);
34018 if (PyErr_Occurred()) SWIG_fail;
34019 }
34020 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34021 return resultobj;
34022 fail:
34023 return NULL;
34024 }
34025
34026
34027 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34028 PyObject *resultobj = 0;
34029 wxWindow *arg1 = (wxWindow *) 0 ;
34030 wxSize *arg2 = 0 ;
34031 wxSize result;
34032 void *argp1 = 0 ;
34033 int res1 = 0 ;
34034 wxSize temp2 ;
34035 PyObject * obj0 = 0 ;
34036 PyObject * obj1 = 0 ;
34037 char * kwnames[] = {
34038 (char *) "self",(char *) "sz", NULL
34039 };
34040
34041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34043 if (!SWIG_IsOK(res1)) {
34044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34045 }
34046 arg1 = reinterpret_cast< wxWindow * >(argp1);
34047 {
34048 arg2 = &temp2;
34049 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34050 }
34051 {
34052 PyThreadState* __tstate = wxPyBeginAllowThreads();
34053 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34054 wxPyEndAllowThreads(__tstate);
34055 if (PyErr_Occurred()) SWIG_fail;
34056 }
34057 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34058 return resultobj;
34059 fail:
34060 return NULL;
34061 }
34062
34063
34064 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34065 PyObject *resultobj = 0;
34066 wxWindow *arg1 = (wxWindow *) 0 ;
34067 wxPoint *arg2 = 0 ;
34068 wxPoint result;
34069 void *argp1 = 0 ;
34070 int res1 = 0 ;
34071 wxPoint temp2 ;
34072 PyObject * obj0 = 0 ;
34073 PyObject * obj1 = 0 ;
34074 char * kwnames[] = {
34075 (char *) "self",(char *) "pt", NULL
34076 };
34077
34078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34080 if (!SWIG_IsOK(res1)) {
34081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34082 }
34083 arg1 = reinterpret_cast< wxWindow * >(argp1);
34084 {
34085 arg2 = &temp2;
34086 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34087 }
34088 {
34089 PyThreadState* __tstate = wxPyBeginAllowThreads();
34090 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34091 wxPyEndAllowThreads(__tstate);
34092 if (PyErr_Occurred()) SWIG_fail;
34093 }
34094 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34095 return resultobj;
34096 fail:
34097 return NULL;
34098 }
34099
34100
34101 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34102 PyObject *resultobj = 0;
34103 wxWindow *arg1 = (wxWindow *) 0 ;
34104 wxSize *arg2 = 0 ;
34105 wxSize result;
34106 void *argp1 = 0 ;
34107 int res1 = 0 ;
34108 wxSize temp2 ;
34109 PyObject * obj0 = 0 ;
34110 PyObject * obj1 = 0 ;
34111 char * kwnames[] = {
34112 (char *) "self",(char *) "sz", NULL
34113 };
34114
34115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34117 if (!SWIG_IsOK(res1)) {
34118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34119 }
34120 arg1 = reinterpret_cast< wxWindow * >(argp1);
34121 {
34122 arg2 = &temp2;
34123 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34124 }
34125 {
34126 PyThreadState* __tstate = wxPyBeginAllowThreads();
34127 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34128 wxPyEndAllowThreads(__tstate);
34129 if (PyErr_Occurred()) SWIG_fail;
34130 }
34131 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34132 return resultobj;
34133 fail:
34134 return NULL;
34135 }
34136
34137
34138 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34139 PyObject *resultobj = 0;
34140 wxWindow *arg1 = (wxWindow *) 0 ;
34141 int arg2 ;
34142 int arg3 ;
34143 void *argp1 = 0 ;
34144 int res1 = 0 ;
34145 int val2 ;
34146 int ecode2 = 0 ;
34147 int val3 ;
34148 int ecode3 = 0 ;
34149 PyObject * obj0 = 0 ;
34150 PyObject * obj1 = 0 ;
34151 PyObject * obj2 = 0 ;
34152 char * kwnames[] = {
34153 (char *) "self",(char *) "x",(char *) "y", NULL
34154 };
34155
34156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34158 if (!SWIG_IsOK(res1)) {
34159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34160 }
34161 arg1 = reinterpret_cast< wxWindow * >(argp1);
34162 ecode2 = SWIG_AsVal_int(obj1, &val2);
34163 if (!SWIG_IsOK(ecode2)) {
34164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34165 }
34166 arg2 = static_cast< int >(val2);
34167 ecode3 = SWIG_AsVal_int(obj2, &val3);
34168 if (!SWIG_IsOK(ecode3)) {
34169 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34170 }
34171 arg3 = static_cast< int >(val3);
34172 {
34173 PyThreadState* __tstate = wxPyBeginAllowThreads();
34174 (arg1)->WarpPointer(arg2,arg3);
34175 wxPyEndAllowThreads(__tstate);
34176 if (PyErr_Occurred()) SWIG_fail;
34177 }
34178 resultobj = SWIG_Py_Void();
34179 return resultobj;
34180 fail:
34181 return NULL;
34182 }
34183
34184
34185 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34186 PyObject *resultobj = 0;
34187 wxWindow *arg1 = (wxWindow *) 0 ;
34188 void *argp1 = 0 ;
34189 int res1 = 0 ;
34190 PyObject *swig_obj[1] ;
34191
34192 if (!args) SWIG_fail;
34193 swig_obj[0] = args;
34194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34195 if (!SWIG_IsOK(res1)) {
34196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34197 }
34198 arg1 = reinterpret_cast< wxWindow * >(argp1);
34199 {
34200 PyThreadState* __tstate = wxPyBeginAllowThreads();
34201 (arg1)->CaptureMouse();
34202 wxPyEndAllowThreads(__tstate);
34203 if (PyErr_Occurred()) SWIG_fail;
34204 }
34205 resultobj = SWIG_Py_Void();
34206 return resultobj;
34207 fail:
34208 return NULL;
34209 }
34210
34211
34212 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34213 PyObject *resultobj = 0;
34214 wxWindow *arg1 = (wxWindow *) 0 ;
34215 void *argp1 = 0 ;
34216 int res1 = 0 ;
34217 PyObject *swig_obj[1] ;
34218
34219 if (!args) SWIG_fail;
34220 swig_obj[0] = args;
34221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34222 if (!SWIG_IsOK(res1)) {
34223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34224 }
34225 arg1 = reinterpret_cast< wxWindow * >(argp1);
34226 {
34227 PyThreadState* __tstate = wxPyBeginAllowThreads();
34228 (arg1)->ReleaseMouse();
34229 wxPyEndAllowThreads(__tstate);
34230 if (PyErr_Occurred()) SWIG_fail;
34231 }
34232 resultobj = SWIG_Py_Void();
34233 return resultobj;
34234 fail:
34235 return NULL;
34236 }
34237
34238
34239 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34240 PyObject *resultobj = 0;
34241 wxWindow *result = 0 ;
34242
34243 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34244 {
34245 if (!wxPyCheckForApp()) SWIG_fail;
34246 PyThreadState* __tstate = wxPyBeginAllowThreads();
34247 result = (wxWindow *)wxWindow::GetCapture();
34248 wxPyEndAllowThreads(__tstate);
34249 if (PyErr_Occurred()) SWIG_fail;
34250 }
34251 {
34252 resultobj = wxPyMake_wxObject(result, 0);
34253 }
34254 return resultobj;
34255 fail:
34256 return NULL;
34257 }
34258
34259
34260 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34261 PyObject *resultobj = 0;
34262 wxWindow *arg1 = (wxWindow *) 0 ;
34263 bool result;
34264 void *argp1 = 0 ;
34265 int res1 = 0 ;
34266 PyObject *swig_obj[1] ;
34267
34268 if (!args) SWIG_fail;
34269 swig_obj[0] = args;
34270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34271 if (!SWIG_IsOK(res1)) {
34272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34273 }
34274 arg1 = reinterpret_cast< wxWindow * >(argp1);
34275 {
34276 PyThreadState* __tstate = wxPyBeginAllowThreads();
34277 result = (bool)((wxWindow const *)arg1)->HasCapture();
34278 wxPyEndAllowThreads(__tstate);
34279 if (PyErr_Occurred()) SWIG_fail;
34280 }
34281 {
34282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34283 }
34284 return resultobj;
34285 fail:
34286 return NULL;
34287 }
34288
34289
34290 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34291 PyObject *resultobj = 0;
34292 wxWindow *arg1 = (wxWindow *) 0 ;
34293 bool arg2 = (bool) true ;
34294 wxRect *arg3 = (wxRect *) NULL ;
34295 void *argp1 = 0 ;
34296 int res1 = 0 ;
34297 bool val2 ;
34298 int ecode2 = 0 ;
34299 void *argp3 = 0 ;
34300 int res3 = 0 ;
34301 PyObject * obj0 = 0 ;
34302 PyObject * obj1 = 0 ;
34303 PyObject * obj2 = 0 ;
34304 char * kwnames[] = {
34305 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34306 };
34307
34308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34310 if (!SWIG_IsOK(res1)) {
34311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34312 }
34313 arg1 = reinterpret_cast< wxWindow * >(argp1);
34314 if (obj1) {
34315 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34316 if (!SWIG_IsOK(ecode2)) {
34317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34318 }
34319 arg2 = static_cast< bool >(val2);
34320 }
34321 if (obj2) {
34322 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34323 if (!SWIG_IsOK(res3)) {
34324 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34325 }
34326 arg3 = reinterpret_cast< wxRect * >(argp3);
34327 }
34328 {
34329 PyThreadState* __tstate = wxPyBeginAllowThreads();
34330 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34331 wxPyEndAllowThreads(__tstate);
34332 if (PyErr_Occurred()) SWIG_fail;
34333 }
34334 resultobj = SWIG_Py_Void();
34335 return resultobj;
34336 fail:
34337 return NULL;
34338 }
34339
34340
34341 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34342 PyObject *resultobj = 0;
34343 wxWindow *arg1 = (wxWindow *) 0 ;
34344 wxRect *arg2 = 0 ;
34345 bool arg3 = (bool) true ;
34346 void *argp1 = 0 ;
34347 int res1 = 0 ;
34348 wxRect temp2 ;
34349 bool val3 ;
34350 int ecode3 = 0 ;
34351 PyObject * obj0 = 0 ;
34352 PyObject * obj1 = 0 ;
34353 PyObject * obj2 = 0 ;
34354 char * kwnames[] = {
34355 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34356 };
34357
34358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34360 if (!SWIG_IsOK(res1)) {
34361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34362 }
34363 arg1 = reinterpret_cast< wxWindow * >(argp1);
34364 {
34365 arg2 = &temp2;
34366 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34367 }
34368 if (obj2) {
34369 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34370 if (!SWIG_IsOK(ecode3)) {
34371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34372 }
34373 arg3 = static_cast< bool >(val3);
34374 }
34375 {
34376 PyThreadState* __tstate = wxPyBeginAllowThreads();
34377 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34378 wxPyEndAllowThreads(__tstate);
34379 if (PyErr_Occurred()) SWIG_fail;
34380 }
34381 resultobj = SWIG_Py_Void();
34382 return resultobj;
34383 fail:
34384 return NULL;
34385 }
34386
34387
34388 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34389 PyObject *resultobj = 0;
34390 wxWindow *arg1 = (wxWindow *) 0 ;
34391 void *argp1 = 0 ;
34392 int res1 = 0 ;
34393 PyObject *swig_obj[1] ;
34394
34395 if (!args) SWIG_fail;
34396 swig_obj[0] = args;
34397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34398 if (!SWIG_IsOK(res1)) {
34399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34400 }
34401 arg1 = reinterpret_cast< wxWindow * >(argp1);
34402 {
34403 PyThreadState* __tstate = wxPyBeginAllowThreads();
34404 (arg1)->Update();
34405 wxPyEndAllowThreads(__tstate);
34406 if (PyErr_Occurred()) SWIG_fail;
34407 }
34408 resultobj = SWIG_Py_Void();
34409 return resultobj;
34410 fail:
34411 return NULL;
34412 }
34413
34414
34415 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34416 PyObject *resultobj = 0;
34417 wxWindow *arg1 = (wxWindow *) 0 ;
34418 void *argp1 = 0 ;
34419 int res1 = 0 ;
34420 PyObject *swig_obj[1] ;
34421
34422 if (!args) SWIG_fail;
34423 swig_obj[0] = args;
34424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34425 if (!SWIG_IsOK(res1)) {
34426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34427 }
34428 arg1 = reinterpret_cast< wxWindow * >(argp1);
34429 {
34430 PyThreadState* __tstate = wxPyBeginAllowThreads();
34431 (arg1)->ClearBackground();
34432 wxPyEndAllowThreads(__tstate);
34433 if (PyErr_Occurred()) SWIG_fail;
34434 }
34435 resultobj = SWIG_Py_Void();
34436 return resultobj;
34437 fail:
34438 return NULL;
34439 }
34440
34441
34442 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34443 PyObject *resultobj = 0;
34444 wxWindow *arg1 = (wxWindow *) 0 ;
34445 void *argp1 = 0 ;
34446 int res1 = 0 ;
34447 PyObject *swig_obj[1] ;
34448
34449 if (!args) SWIG_fail;
34450 swig_obj[0] = args;
34451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34452 if (!SWIG_IsOK(res1)) {
34453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34454 }
34455 arg1 = reinterpret_cast< wxWindow * >(argp1);
34456 {
34457 PyThreadState* __tstate = wxPyBeginAllowThreads();
34458 (arg1)->Freeze();
34459 wxPyEndAllowThreads(__tstate);
34460 if (PyErr_Occurred()) SWIG_fail;
34461 }
34462 resultobj = SWIG_Py_Void();
34463 return resultobj;
34464 fail:
34465 return NULL;
34466 }
34467
34468
34469 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34470 PyObject *resultobj = 0;
34471 wxWindow *arg1 = (wxWindow *) 0 ;
34472 void *argp1 = 0 ;
34473 int res1 = 0 ;
34474 PyObject *swig_obj[1] ;
34475
34476 if (!args) SWIG_fail;
34477 swig_obj[0] = args;
34478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34479 if (!SWIG_IsOK(res1)) {
34480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34481 }
34482 arg1 = reinterpret_cast< wxWindow * >(argp1);
34483 {
34484 PyThreadState* __tstate = wxPyBeginAllowThreads();
34485 (arg1)->Thaw();
34486 wxPyEndAllowThreads(__tstate);
34487 if (PyErr_Occurred()) SWIG_fail;
34488 }
34489 resultobj = SWIG_Py_Void();
34490 return resultobj;
34491 fail:
34492 return NULL;
34493 }
34494
34495
34496 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34497 PyObject *resultobj = 0;
34498 wxWindow *arg1 = (wxWindow *) 0 ;
34499 wxDC *arg2 = 0 ;
34500 void *argp1 = 0 ;
34501 int res1 = 0 ;
34502 void *argp2 = 0 ;
34503 int res2 = 0 ;
34504 PyObject * obj0 = 0 ;
34505 PyObject * obj1 = 0 ;
34506 char * kwnames[] = {
34507 (char *) "self",(char *) "dc", NULL
34508 };
34509
34510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34512 if (!SWIG_IsOK(res1)) {
34513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34514 }
34515 arg1 = reinterpret_cast< wxWindow * >(argp1);
34516 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34517 if (!SWIG_IsOK(res2)) {
34518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34519 }
34520 if (!argp2) {
34521 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34522 }
34523 arg2 = reinterpret_cast< wxDC * >(argp2);
34524 {
34525 PyThreadState* __tstate = wxPyBeginAllowThreads();
34526 (arg1)->PrepareDC(*arg2);
34527 wxPyEndAllowThreads(__tstate);
34528 if (PyErr_Occurred()) SWIG_fail;
34529 }
34530 resultobj = SWIG_Py_Void();
34531 return resultobj;
34532 fail:
34533 return NULL;
34534 }
34535
34536
34537 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34538 PyObject *resultobj = 0;
34539 wxWindow *arg1 = (wxWindow *) 0 ;
34540 wxRegion *result = 0 ;
34541 void *argp1 = 0 ;
34542 int res1 = 0 ;
34543 PyObject *swig_obj[1] ;
34544
34545 if (!args) SWIG_fail;
34546 swig_obj[0] = args;
34547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34548 if (!SWIG_IsOK(res1)) {
34549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34550 }
34551 arg1 = reinterpret_cast< wxWindow * >(argp1);
34552 {
34553 PyThreadState* __tstate = wxPyBeginAllowThreads();
34554 {
34555 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34556 result = (wxRegion *) &_result_ref;
34557 }
34558 wxPyEndAllowThreads(__tstate);
34559 if (PyErr_Occurred()) SWIG_fail;
34560 }
34561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34562 return resultobj;
34563 fail:
34564 return NULL;
34565 }
34566
34567
34568 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34569 PyObject *resultobj = 0;
34570 wxWindow *arg1 = (wxWindow *) 0 ;
34571 wxRect result;
34572 void *argp1 = 0 ;
34573 int res1 = 0 ;
34574 PyObject *swig_obj[1] ;
34575
34576 if (!args) SWIG_fail;
34577 swig_obj[0] = args;
34578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34579 if (!SWIG_IsOK(res1)) {
34580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34581 }
34582 arg1 = reinterpret_cast< wxWindow * >(argp1);
34583 {
34584 PyThreadState* __tstate = wxPyBeginAllowThreads();
34585 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34586 wxPyEndAllowThreads(__tstate);
34587 if (PyErr_Occurred()) SWIG_fail;
34588 }
34589 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34590 return resultobj;
34591 fail:
34592 return NULL;
34593 }
34594
34595
34596 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34597 PyObject *resultobj = 0;
34598 wxWindow *arg1 = (wxWindow *) 0 ;
34599 int arg2 ;
34600 int arg3 ;
34601 int arg4 = (int) 1 ;
34602 int arg5 = (int) 1 ;
34603 bool result;
34604 void *argp1 = 0 ;
34605 int res1 = 0 ;
34606 int val2 ;
34607 int ecode2 = 0 ;
34608 int val3 ;
34609 int ecode3 = 0 ;
34610 int val4 ;
34611 int ecode4 = 0 ;
34612 int val5 ;
34613 int ecode5 = 0 ;
34614 PyObject * obj0 = 0 ;
34615 PyObject * obj1 = 0 ;
34616 PyObject * obj2 = 0 ;
34617 PyObject * obj3 = 0 ;
34618 PyObject * obj4 = 0 ;
34619 char * kwnames[] = {
34620 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34621 };
34622
34623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34625 if (!SWIG_IsOK(res1)) {
34626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34627 }
34628 arg1 = reinterpret_cast< wxWindow * >(argp1);
34629 ecode2 = SWIG_AsVal_int(obj1, &val2);
34630 if (!SWIG_IsOK(ecode2)) {
34631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34632 }
34633 arg2 = static_cast< int >(val2);
34634 ecode3 = SWIG_AsVal_int(obj2, &val3);
34635 if (!SWIG_IsOK(ecode3)) {
34636 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34637 }
34638 arg3 = static_cast< int >(val3);
34639 if (obj3) {
34640 ecode4 = SWIG_AsVal_int(obj3, &val4);
34641 if (!SWIG_IsOK(ecode4)) {
34642 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34643 }
34644 arg4 = static_cast< int >(val4);
34645 }
34646 if (obj4) {
34647 ecode5 = SWIG_AsVal_int(obj4, &val5);
34648 if (!SWIG_IsOK(ecode5)) {
34649 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34650 }
34651 arg5 = static_cast< int >(val5);
34652 }
34653 {
34654 PyThreadState* __tstate = wxPyBeginAllowThreads();
34655 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34656 wxPyEndAllowThreads(__tstate);
34657 if (PyErr_Occurred()) SWIG_fail;
34658 }
34659 {
34660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34661 }
34662 return resultobj;
34663 fail:
34664 return NULL;
34665 }
34666
34667
34668 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34669 PyObject *resultobj = 0;
34670 wxWindow *arg1 = (wxWindow *) 0 ;
34671 wxPoint *arg2 = 0 ;
34672 bool result;
34673 void *argp1 = 0 ;
34674 int res1 = 0 ;
34675 wxPoint temp2 ;
34676 PyObject * obj0 = 0 ;
34677 PyObject * obj1 = 0 ;
34678 char * kwnames[] = {
34679 (char *) "self",(char *) "pt", NULL
34680 };
34681
34682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34684 if (!SWIG_IsOK(res1)) {
34685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34686 }
34687 arg1 = reinterpret_cast< wxWindow * >(argp1);
34688 {
34689 arg2 = &temp2;
34690 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34691 }
34692 {
34693 PyThreadState* __tstate = wxPyBeginAllowThreads();
34694 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34695 wxPyEndAllowThreads(__tstate);
34696 if (PyErr_Occurred()) SWIG_fail;
34697 }
34698 {
34699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34700 }
34701 return resultobj;
34702 fail:
34703 return NULL;
34704 }
34705
34706
34707 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34708 PyObject *resultobj = 0;
34709 wxWindow *arg1 = (wxWindow *) 0 ;
34710 wxRect *arg2 = 0 ;
34711 bool result;
34712 void *argp1 = 0 ;
34713 int res1 = 0 ;
34714 wxRect temp2 ;
34715 PyObject * obj0 = 0 ;
34716 PyObject * obj1 = 0 ;
34717 char * kwnames[] = {
34718 (char *) "self",(char *) "rect", NULL
34719 };
34720
34721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34723 if (!SWIG_IsOK(res1)) {
34724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34725 }
34726 arg1 = reinterpret_cast< wxWindow * >(argp1);
34727 {
34728 arg2 = &temp2;
34729 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34730 }
34731 {
34732 PyThreadState* __tstate = wxPyBeginAllowThreads();
34733 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34734 wxPyEndAllowThreads(__tstate);
34735 if (PyErr_Occurred()) SWIG_fail;
34736 }
34737 {
34738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34739 }
34740 return resultobj;
34741 fail:
34742 return NULL;
34743 }
34744
34745
34746 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34747 PyObject *resultobj = 0;
34748 wxWindow *arg1 = (wxWindow *) 0 ;
34749 SwigValueWrapper<wxVisualAttributes > result;
34750 void *argp1 = 0 ;
34751 int res1 = 0 ;
34752 PyObject *swig_obj[1] ;
34753
34754 if (!args) SWIG_fail;
34755 swig_obj[0] = args;
34756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34757 if (!SWIG_IsOK(res1)) {
34758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34759 }
34760 arg1 = reinterpret_cast< wxWindow * >(argp1);
34761 {
34762 PyThreadState* __tstate = wxPyBeginAllowThreads();
34763 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34764 wxPyEndAllowThreads(__tstate);
34765 if (PyErr_Occurred()) SWIG_fail;
34766 }
34767 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34768 return resultobj;
34769 fail:
34770 return NULL;
34771 }
34772
34773
34774 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34775 PyObject *resultobj = 0;
34776 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34777 SwigValueWrapper<wxVisualAttributes > result;
34778 int val1 ;
34779 int ecode1 = 0 ;
34780 PyObject * obj0 = 0 ;
34781 char * kwnames[] = {
34782 (char *) "variant", NULL
34783 };
34784
34785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34786 if (obj0) {
34787 ecode1 = SWIG_AsVal_int(obj0, &val1);
34788 if (!SWIG_IsOK(ecode1)) {
34789 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34790 }
34791 arg1 = static_cast< wxWindowVariant >(val1);
34792 }
34793 {
34794 if (!wxPyCheckForApp()) SWIG_fail;
34795 PyThreadState* __tstate = wxPyBeginAllowThreads();
34796 result = wxWindow::GetClassDefaultAttributes(arg1);
34797 wxPyEndAllowThreads(__tstate);
34798 if (PyErr_Occurred()) SWIG_fail;
34799 }
34800 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34801 return resultobj;
34802 fail:
34803 return NULL;
34804 }
34805
34806
34807 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34808 PyObject *resultobj = 0;
34809 wxWindow *arg1 = (wxWindow *) 0 ;
34810 wxColour *arg2 = 0 ;
34811 bool result;
34812 void *argp1 = 0 ;
34813 int res1 = 0 ;
34814 wxColour temp2 ;
34815 PyObject * obj0 = 0 ;
34816 PyObject * obj1 = 0 ;
34817 char * kwnames[] = {
34818 (char *) "self",(char *) "colour", NULL
34819 };
34820
34821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34823 if (!SWIG_IsOK(res1)) {
34824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34825 }
34826 arg1 = reinterpret_cast< wxWindow * >(argp1);
34827 {
34828 arg2 = &temp2;
34829 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34830 }
34831 {
34832 PyThreadState* __tstate = wxPyBeginAllowThreads();
34833 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34834 wxPyEndAllowThreads(__tstate);
34835 if (PyErr_Occurred()) SWIG_fail;
34836 }
34837 {
34838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34839 }
34840 return resultobj;
34841 fail:
34842 return NULL;
34843 }
34844
34845
34846 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34847 PyObject *resultobj = 0;
34848 wxWindow *arg1 = (wxWindow *) 0 ;
34849 wxColour *arg2 = 0 ;
34850 void *argp1 = 0 ;
34851 int res1 = 0 ;
34852 wxColour temp2 ;
34853 PyObject * obj0 = 0 ;
34854 PyObject * obj1 = 0 ;
34855 char * kwnames[] = {
34856 (char *) "self",(char *) "colour", NULL
34857 };
34858
34859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34861 if (!SWIG_IsOK(res1)) {
34862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34863 }
34864 arg1 = reinterpret_cast< wxWindow * >(argp1);
34865 {
34866 arg2 = &temp2;
34867 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34868 }
34869 {
34870 PyThreadState* __tstate = wxPyBeginAllowThreads();
34871 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34872 wxPyEndAllowThreads(__tstate);
34873 if (PyErr_Occurred()) SWIG_fail;
34874 }
34875 resultobj = SWIG_Py_Void();
34876 return resultobj;
34877 fail:
34878 return NULL;
34879 }
34880
34881
34882 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34883 PyObject *resultobj = 0;
34884 wxWindow *arg1 = (wxWindow *) 0 ;
34885 wxColour *arg2 = 0 ;
34886 bool result;
34887 void *argp1 = 0 ;
34888 int res1 = 0 ;
34889 wxColour temp2 ;
34890 PyObject * obj0 = 0 ;
34891 PyObject * obj1 = 0 ;
34892 char * kwnames[] = {
34893 (char *) "self",(char *) "colour", NULL
34894 };
34895
34896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34898 if (!SWIG_IsOK(res1)) {
34899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34900 }
34901 arg1 = reinterpret_cast< wxWindow * >(argp1);
34902 {
34903 arg2 = &temp2;
34904 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34905 }
34906 {
34907 PyThreadState* __tstate = wxPyBeginAllowThreads();
34908 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
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_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34922 PyObject *resultobj = 0;
34923 wxWindow *arg1 = (wxWindow *) 0 ;
34924 wxColour *arg2 = 0 ;
34925 void *argp1 = 0 ;
34926 int res1 = 0 ;
34927 wxColour temp2 ;
34928 PyObject * obj0 = 0 ;
34929 PyObject * obj1 = 0 ;
34930 char * kwnames[] = {
34931 (char *) "self",(char *) "colour", NULL
34932 };
34933
34934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34936 if (!SWIG_IsOK(res1)) {
34937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34938 }
34939 arg1 = reinterpret_cast< wxWindow * >(argp1);
34940 {
34941 arg2 = &temp2;
34942 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34943 }
34944 {
34945 PyThreadState* __tstate = wxPyBeginAllowThreads();
34946 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34947 wxPyEndAllowThreads(__tstate);
34948 if (PyErr_Occurred()) SWIG_fail;
34949 }
34950 resultobj = SWIG_Py_Void();
34951 return resultobj;
34952 fail:
34953 return NULL;
34954 }
34955
34956
34957 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34958 PyObject *resultobj = 0;
34959 wxWindow *arg1 = (wxWindow *) 0 ;
34960 wxColour result;
34961 void *argp1 = 0 ;
34962 int res1 = 0 ;
34963 PyObject *swig_obj[1] ;
34964
34965 if (!args) SWIG_fail;
34966 swig_obj[0] = args;
34967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34968 if (!SWIG_IsOK(res1)) {
34969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34970 }
34971 arg1 = reinterpret_cast< wxWindow * >(argp1);
34972 {
34973 PyThreadState* __tstate = wxPyBeginAllowThreads();
34974 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34975 wxPyEndAllowThreads(__tstate);
34976 if (PyErr_Occurred()) SWIG_fail;
34977 }
34978 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34979 return resultobj;
34980 fail:
34981 return NULL;
34982 }
34983
34984
34985 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34986 PyObject *resultobj = 0;
34987 wxWindow *arg1 = (wxWindow *) 0 ;
34988 wxColour result;
34989 void *argp1 = 0 ;
34990 int res1 = 0 ;
34991 PyObject *swig_obj[1] ;
34992
34993 if (!args) SWIG_fail;
34994 swig_obj[0] = args;
34995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34996 if (!SWIG_IsOK(res1)) {
34997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34998 }
34999 arg1 = reinterpret_cast< wxWindow * >(argp1);
35000 {
35001 PyThreadState* __tstate = wxPyBeginAllowThreads();
35002 result = ((wxWindow const *)arg1)->GetForegroundColour();
35003 wxPyEndAllowThreads(__tstate);
35004 if (PyErr_Occurred()) SWIG_fail;
35005 }
35006 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35007 return resultobj;
35008 fail:
35009 return NULL;
35010 }
35011
35012
35013 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35014 PyObject *resultobj = 0;
35015 wxWindow *arg1 = (wxWindow *) 0 ;
35016 bool result;
35017 void *argp1 = 0 ;
35018 int res1 = 0 ;
35019 PyObject *swig_obj[1] ;
35020
35021 if (!args) SWIG_fail;
35022 swig_obj[0] = args;
35023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35024 if (!SWIG_IsOK(res1)) {
35025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35026 }
35027 arg1 = reinterpret_cast< wxWindow * >(argp1);
35028 {
35029 PyThreadState* __tstate = wxPyBeginAllowThreads();
35030 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35031 wxPyEndAllowThreads(__tstate);
35032 if (PyErr_Occurred()) SWIG_fail;
35033 }
35034 {
35035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35036 }
35037 return resultobj;
35038 fail:
35039 return NULL;
35040 }
35041
35042
35043 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35044 PyObject *resultobj = 0;
35045 wxWindow *arg1 = (wxWindow *) 0 ;
35046 bool result;
35047 void *argp1 = 0 ;
35048 int res1 = 0 ;
35049 PyObject *swig_obj[1] ;
35050
35051 if (!args) SWIG_fail;
35052 swig_obj[0] = args;
35053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35054 if (!SWIG_IsOK(res1)) {
35055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35056 }
35057 arg1 = reinterpret_cast< wxWindow * >(argp1);
35058 {
35059 PyThreadState* __tstate = wxPyBeginAllowThreads();
35060 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35061 wxPyEndAllowThreads(__tstate);
35062 if (PyErr_Occurred()) SWIG_fail;
35063 }
35064 {
35065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35066 }
35067 return resultobj;
35068 fail:
35069 return NULL;
35070 }
35071
35072
35073 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35074 PyObject *resultobj = 0;
35075 wxWindow *arg1 = (wxWindow *) 0 ;
35076 wxBackgroundStyle arg2 ;
35077 bool result;
35078 void *argp1 = 0 ;
35079 int res1 = 0 ;
35080 int val2 ;
35081 int ecode2 = 0 ;
35082 PyObject * obj0 = 0 ;
35083 PyObject * obj1 = 0 ;
35084 char * kwnames[] = {
35085 (char *) "self",(char *) "style", NULL
35086 };
35087
35088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35090 if (!SWIG_IsOK(res1)) {
35091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35092 }
35093 arg1 = reinterpret_cast< wxWindow * >(argp1);
35094 ecode2 = SWIG_AsVal_int(obj1, &val2);
35095 if (!SWIG_IsOK(ecode2)) {
35096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35097 }
35098 arg2 = static_cast< wxBackgroundStyle >(val2);
35099 {
35100 PyThreadState* __tstate = wxPyBeginAllowThreads();
35101 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35102 wxPyEndAllowThreads(__tstate);
35103 if (PyErr_Occurred()) SWIG_fail;
35104 }
35105 {
35106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35107 }
35108 return resultobj;
35109 fail:
35110 return NULL;
35111 }
35112
35113
35114 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35115 PyObject *resultobj = 0;
35116 wxWindow *arg1 = (wxWindow *) 0 ;
35117 wxBackgroundStyle result;
35118 void *argp1 = 0 ;
35119 int res1 = 0 ;
35120 PyObject *swig_obj[1] ;
35121
35122 if (!args) SWIG_fail;
35123 swig_obj[0] = args;
35124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35125 if (!SWIG_IsOK(res1)) {
35126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35127 }
35128 arg1 = reinterpret_cast< wxWindow * >(argp1);
35129 {
35130 PyThreadState* __tstate = wxPyBeginAllowThreads();
35131 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35132 wxPyEndAllowThreads(__tstate);
35133 if (PyErr_Occurred()) SWIG_fail;
35134 }
35135 resultobj = SWIG_From_int(static_cast< int >(result));
35136 return resultobj;
35137 fail:
35138 return NULL;
35139 }
35140
35141
35142 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35143 PyObject *resultobj = 0;
35144 wxWindow *arg1 = (wxWindow *) 0 ;
35145 bool result;
35146 void *argp1 = 0 ;
35147 int res1 = 0 ;
35148 PyObject *swig_obj[1] ;
35149
35150 if (!args) SWIG_fail;
35151 swig_obj[0] = args;
35152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35153 if (!SWIG_IsOK(res1)) {
35154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35155 }
35156 arg1 = reinterpret_cast< wxWindow * >(argp1);
35157 {
35158 PyThreadState* __tstate = wxPyBeginAllowThreads();
35159 result = (bool)(arg1)->HasTransparentBackground();
35160 wxPyEndAllowThreads(__tstate);
35161 if (PyErr_Occurred()) SWIG_fail;
35162 }
35163 {
35164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35165 }
35166 return resultobj;
35167 fail:
35168 return NULL;
35169 }
35170
35171
35172 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35173 PyObject *resultobj = 0;
35174 wxWindow *arg1 = (wxWindow *) 0 ;
35175 wxCursor *arg2 = 0 ;
35176 bool result;
35177 void *argp1 = 0 ;
35178 int res1 = 0 ;
35179 void *argp2 = 0 ;
35180 int res2 = 0 ;
35181 PyObject * obj0 = 0 ;
35182 PyObject * obj1 = 0 ;
35183 char * kwnames[] = {
35184 (char *) "self",(char *) "cursor", NULL
35185 };
35186
35187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35189 if (!SWIG_IsOK(res1)) {
35190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35191 }
35192 arg1 = reinterpret_cast< wxWindow * >(argp1);
35193 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35194 if (!SWIG_IsOK(res2)) {
35195 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35196 }
35197 if (!argp2) {
35198 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35199 }
35200 arg2 = reinterpret_cast< wxCursor * >(argp2);
35201 {
35202 PyThreadState* __tstate = wxPyBeginAllowThreads();
35203 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35204 wxPyEndAllowThreads(__tstate);
35205 if (PyErr_Occurred()) SWIG_fail;
35206 }
35207 {
35208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35209 }
35210 return resultobj;
35211 fail:
35212 return NULL;
35213 }
35214
35215
35216 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35217 PyObject *resultobj = 0;
35218 wxWindow *arg1 = (wxWindow *) 0 ;
35219 wxCursor result;
35220 void *argp1 = 0 ;
35221 int res1 = 0 ;
35222 PyObject *swig_obj[1] ;
35223
35224 if (!args) SWIG_fail;
35225 swig_obj[0] = args;
35226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35227 if (!SWIG_IsOK(res1)) {
35228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35229 }
35230 arg1 = reinterpret_cast< wxWindow * >(argp1);
35231 {
35232 PyThreadState* __tstate = wxPyBeginAllowThreads();
35233 result = (arg1)->GetCursor();
35234 wxPyEndAllowThreads(__tstate);
35235 if (PyErr_Occurred()) SWIG_fail;
35236 }
35237 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35238 return resultobj;
35239 fail:
35240 return NULL;
35241 }
35242
35243
35244 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35245 PyObject *resultobj = 0;
35246 wxWindow *arg1 = (wxWindow *) 0 ;
35247 wxFont *arg2 = 0 ;
35248 bool result;
35249 void *argp1 = 0 ;
35250 int res1 = 0 ;
35251 void *argp2 = 0 ;
35252 int res2 = 0 ;
35253 PyObject * obj0 = 0 ;
35254 PyObject * obj1 = 0 ;
35255 char * kwnames[] = {
35256 (char *) "self",(char *) "font", NULL
35257 };
35258
35259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35261 if (!SWIG_IsOK(res1)) {
35262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35263 }
35264 arg1 = reinterpret_cast< wxWindow * >(argp1);
35265 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35266 if (!SWIG_IsOK(res2)) {
35267 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35268 }
35269 if (!argp2) {
35270 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35271 }
35272 arg2 = reinterpret_cast< wxFont * >(argp2);
35273 {
35274 PyThreadState* __tstate = wxPyBeginAllowThreads();
35275 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35276 wxPyEndAllowThreads(__tstate);
35277 if (PyErr_Occurred()) SWIG_fail;
35278 }
35279 {
35280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35281 }
35282 return resultobj;
35283 fail:
35284 return NULL;
35285 }
35286
35287
35288 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35289 PyObject *resultobj = 0;
35290 wxWindow *arg1 = (wxWindow *) 0 ;
35291 wxFont *arg2 = 0 ;
35292 void *argp1 = 0 ;
35293 int res1 = 0 ;
35294 void *argp2 = 0 ;
35295 int res2 = 0 ;
35296 PyObject * obj0 = 0 ;
35297 PyObject * obj1 = 0 ;
35298 char * kwnames[] = {
35299 (char *) "self",(char *) "font", NULL
35300 };
35301
35302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35304 if (!SWIG_IsOK(res1)) {
35305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35306 }
35307 arg1 = reinterpret_cast< wxWindow * >(argp1);
35308 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35309 if (!SWIG_IsOK(res2)) {
35310 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35311 }
35312 if (!argp2) {
35313 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35314 }
35315 arg2 = reinterpret_cast< wxFont * >(argp2);
35316 {
35317 PyThreadState* __tstate = wxPyBeginAllowThreads();
35318 (arg1)->SetOwnFont((wxFont const &)*arg2);
35319 wxPyEndAllowThreads(__tstate);
35320 if (PyErr_Occurred()) SWIG_fail;
35321 }
35322 resultobj = SWIG_Py_Void();
35323 return resultobj;
35324 fail:
35325 return NULL;
35326 }
35327
35328
35329 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35330 PyObject *resultobj = 0;
35331 wxWindow *arg1 = (wxWindow *) 0 ;
35332 wxFont result;
35333 void *argp1 = 0 ;
35334 int res1 = 0 ;
35335 PyObject *swig_obj[1] ;
35336
35337 if (!args) SWIG_fail;
35338 swig_obj[0] = args;
35339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35340 if (!SWIG_IsOK(res1)) {
35341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35342 }
35343 arg1 = reinterpret_cast< wxWindow * >(argp1);
35344 {
35345 PyThreadState* __tstate = wxPyBeginAllowThreads();
35346 result = (arg1)->GetFont();
35347 wxPyEndAllowThreads(__tstate);
35348 if (PyErr_Occurred()) SWIG_fail;
35349 }
35350 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35351 return resultobj;
35352 fail:
35353 return NULL;
35354 }
35355
35356
35357 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35358 PyObject *resultobj = 0;
35359 wxWindow *arg1 = (wxWindow *) 0 ;
35360 wxCaret *arg2 = (wxCaret *) 0 ;
35361 void *argp1 = 0 ;
35362 int res1 = 0 ;
35363 int res2 = 0 ;
35364 PyObject * obj0 = 0 ;
35365 PyObject * obj1 = 0 ;
35366 char * kwnames[] = {
35367 (char *) "self",(char *) "caret", NULL
35368 };
35369
35370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35372 if (!SWIG_IsOK(res1)) {
35373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35374 }
35375 arg1 = reinterpret_cast< wxWindow * >(argp1);
35376 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35377 if (!SWIG_IsOK(res2)) {
35378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35379 }
35380 {
35381 PyThreadState* __tstate = wxPyBeginAllowThreads();
35382 (arg1)->SetCaret(arg2);
35383 wxPyEndAllowThreads(__tstate);
35384 if (PyErr_Occurred()) SWIG_fail;
35385 }
35386 resultobj = SWIG_Py_Void();
35387 return resultobj;
35388 fail:
35389 return NULL;
35390 }
35391
35392
35393 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35394 PyObject *resultobj = 0;
35395 wxWindow *arg1 = (wxWindow *) 0 ;
35396 wxCaret *result = 0 ;
35397 void *argp1 = 0 ;
35398 int res1 = 0 ;
35399 PyObject *swig_obj[1] ;
35400
35401 if (!args) SWIG_fail;
35402 swig_obj[0] = args;
35403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35404 if (!SWIG_IsOK(res1)) {
35405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35406 }
35407 arg1 = reinterpret_cast< wxWindow * >(argp1);
35408 {
35409 PyThreadState* __tstate = wxPyBeginAllowThreads();
35410 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35411 wxPyEndAllowThreads(__tstate);
35412 if (PyErr_Occurred()) SWIG_fail;
35413 }
35414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35415 return resultobj;
35416 fail:
35417 return NULL;
35418 }
35419
35420
35421 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35422 PyObject *resultobj = 0;
35423 wxWindow *arg1 = (wxWindow *) 0 ;
35424 int result;
35425 void *argp1 = 0 ;
35426 int res1 = 0 ;
35427 PyObject *swig_obj[1] ;
35428
35429 if (!args) SWIG_fail;
35430 swig_obj[0] = args;
35431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35432 if (!SWIG_IsOK(res1)) {
35433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35434 }
35435 arg1 = reinterpret_cast< wxWindow * >(argp1);
35436 {
35437 PyThreadState* __tstate = wxPyBeginAllowThreads();
35438 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35439 wxPyEndAllowThreads(__tstate);
35440 if (PyErr_Occurred()) SWIG_fail;
35441 }
35442 resultobj = SWIG_From_int(static_cast< int >(result));
35443 return resultobj;
35444 fail:
35445 return NULL;
35446 }
35447
35448
35449 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35450 PyObject *resultobj = 0;
35451 wxWindow *arg1 = (wxWindow *) 0 ;
35452 int result;
35453 void *argp1 = 0 ;
35454 int res1 = 0 ;
35455 PyObject *swig_obj[1] ;
35456
35457 if (!args) SWIG_fail;
35458 swig_obj[0] = args;
35459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35460 if (!SWIG_IsOK(res1)) {
35461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35462 }
35463 arg1 = reinterpret_cast< wxWindow * >(argp1);
35464 {
35465 PyThreadState* __tstate = wxPyBeginAllowThreads();
35466 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35467 wxPyEndAllowThreads(__tstate);
35468 if (PyErr_Occurred()) SWIG_fail;
35469 }
35470 resultobj = SWIG_From_int(static_cast< int >(result));
35471 return resultobj;
35472 fail:
35473 return NULL;
35474 }
35475
35476
35477 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35478 PyObject *resultobj = 0;
35479 wxWindow *arg1 = (wxWindow *) 0 ;
35480 wxString *arg2 = 0 ;
35481 int *arg3 = (int *) 0 ;
35482 int *arg4 = (int *) 0 ;
35483 void *argp1 = 0 ;
35484 int res1 = 0 ;
35485 bool temp2 = false ;
35486 int temp3 ;
35487 int res3 = SWIG_TMPOBJ ;
35488 int temp4 ;
35489 int res4 = SWIG_TMPOBJ ;
35490 PyObject * obj0 = 0 ;
35491 PyObject * obj1 = 0 ;
35492 char * kwnames[] = {
35493 (char *) "self",(char *) "string", NULL
35494 };
35495
35496 arg3 = &temp3;
35497 arg4 = &temp4;
35498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35500 if (!SWIG_IsOK(res1)) {
35501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35502 }
35503 arg1 = reinterpret_cast< wxWindow * >(argp1);
35504 {
35505 arg2 = wxString_in_helper(obj1);
35506 if (arg2 == NULL) SWIG_fail;
35507 temp2 = true;
35508 }
35509 {
35510 PyThreadState* __tstate = wxPyBeginAllowThreads();
35511 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35512 wxPyEndAllowThreads(__tstate);
35513 if (PyErr_Occurred()) SWIG_fail;
35514 }
35515 resultobj = SWIG_Py_Void();
35516 if (SWIG_IsTmpObj(res3)) {
35517 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35518 } else {
35519 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35520 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35521 }
35522 if (SWIG_IsTmpObj(res4)) {
35523 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35524 } else {
35525 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35526 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35527 }
35528 {
35529 if (temp2)
35530 delete arg2;
35531 }
35532 return resultobj;
35533 fail:
35534 {
35535 if (temp2)
35536 delete arg2;
35537 }
35538 return NULL;
35539 }
35540
35541
35542 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35543 PyObject *resultobj = 0;
35544 wxWindow *arg1 = (wxWindow *) 0 ;
35545 wxString *arg2 = 0 ;
35546 int *arg3 = (int *) 0 ;
35547 int *arg4 = (int *) 0 ;
35548 int *arg5 = (int *) 0 ;
35549 int *arg6 = (int *) 0 ;
35550 wxFont *arg7 = (wxFont *) NULL ;
35551 void *argp1 = 0 ;
35552 int res1 = 0 ;
35553 bool temp2 = false ;
35554 int temp3 ;
35555 int res3 = SWIG_TMPOBJ ;
35556 int temp4 ;
35557 int res4 = SWIG_TMPOBJ ;
35558 int temp5 ;
35559 int res5 = SWIG_TMPOBJ ;
35560 int temp6 ;
35561 int res6 = SWIG_TMPOBJ ;
35562 void *argp7 = 0 ;
35563 int res7 = 0 ;
35564 PyObject * obj0 = 0 ;
35565 PyObject * obj1 = 0 ;
35566 PyObject * obj2 = 0 ;
35567 char * kwnames[] = {
35568 (char *) "self",(char *) "string",(char *) "font", NULL
35569 };
35570
35571 arg3 = &temp3;
35572 arg4 = &temp4;
35573 arg5 = &temp5;
35574 arg6 = &temp6;
35575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35577 if (!SWIG_IsOK(res1)) {
35578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35579 }
35580 arg1 = reinterpret_cast< wxWindow * >(argp1);
35581 {
35582 arg2 = wxString_in_helper(obj1);
35583 if (arg2 == NULL) SWIG_fail;
35584 temp2 = true;
35585 }
35586 if (obj2) {
35587 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35588 if (!SWIG_IsOK(res7)) {
35589 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35590 }
35591 arg7 = reinterpret_cast< wxFont * >(argp7);
35592 }
35593 {
35594 PyThreadState* __tstate = wxPyBeginAllowThreads();
35595 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35596 wxPyEndAllowThreads(__tstate);
35597 if (PyErr_Occurred()) SWIG_fail;
35598 }
35599 resultobj = SWIG_Py_Void();
35600 if (SWIG_IsTmpObj(res3)) {
35601 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35602 } else {
35603 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35604 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35605 }
35606 if (SWIG_IsTmpObj(res4)) {
35607 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35608 } else {
35609 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35610 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35611 }
35612 if (SWIG_IsTmpObj(res5)) {
35613 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35614 } else {
35615 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35616 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35617 }
35618 if (SWIG_IsTmpObj(res6)) {
35619 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35620 } else {
35621 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35622 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35623 }
35624 {
35625 if (temp2)
35626 delete arg2;
35627 }
35628 return resultobj;
35629 fail:
35630 {
35631 if (temp2)
35632 delete arg2;
35633 }
35634 return NULL;
35635 }
35636
35637
35638 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35639 PyObject *resultobj = 0;
35640 wxWindow *arg1 = (wxWindow *) 0 ;
35641 int *arg2 = (int *) 0 ;
35642 int *arg3 = (int *) 0 ;
35643 void *argp1 = 0 ;
35644 int res1 = 0 ;
35645 int temp2 ;
35646 int res2 = 0 ;
35647 int temp3 ;
35648 int res3 = 0 ;
35649 PyObject * obj0 = 0 ;
35650 PyObject * obj1 = 0 ;
35651 PyObject * obj2 = 0 ;
35652 char * kwnames[] = {
35653 (char *) "self",(char *) "x",(char *) "y", NULL
35654 };
35655
35656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35658 if (!SWIG_IsOK(res1)) {
35659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35660 }
35661 arg1 = reinterpret_cast< wxWindow * >(argp1);
35662 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35663 int val;
35664 int ecode = SWIG_AsVal_int(obj1, &val);
35665 if (!SWIG_IsOK(ecode)) {
35666 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35667 }
35668 temp2 = static_cast< int >(val);
35669 arg2 = &temp2;
35670 res2 = SWIG_AddTmpMask(ecode);
35671 }
35672 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35673 int val;
35674 int ecode = SWIG_AsVal_int(obj2, &val);
35675 if (!SWIG_IsOK(ecode)) {
35676 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35677 }
35678 temp3 = static_cast< int >(val);
35679 arg3 = &temp3;
35680 res3 = SWIG_AddTmpMask(ecode);
35681 }
35682 {
35683 PyThreadState* __tstate = wxPyBeginAllowThreads();
35684 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35685 wxPyEndAllowThreads(__tstate);
35686 if (PyErr_Occurred()) SWIG_fail;
35687 }
35688 resultobj = SWIG_Py_Void();
35689 if (SWIG_IsTmpObj(res2)) {
35690 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35691 } else {
35692 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35693 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35694 }
35695 if (SWIG_IsTmpObj(res3)) {
35696 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35697 } else {
35698 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35699 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35700 }
35701 return resultobj;
35702 fail:
35703 return NULL;
35704 }
35705
35706
35707 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35708 PyObject *resultobj = 0;
35709 wxWindow *arg1 = (wxWindow *) 0 ;
35710 int *arg2 = (int *) 0 ;
35711 int *arg3 = (int *) 0 ;
35712 void *argp1 = 0 ;
35713 int res1 = 0 ;
35714 int temp2 ;
35715 int res2 = 0 ;
35716 int temp3 ;
35717 int res3 = 0 ;
35718 PyObject * obj0 = 0 ;
35719 PyObject * obj1 = 0 ;
35720 PyObject * obj2 = 0 ;
35721 char * kwnames[] = {
35722 (char *) "self",(char *) "x",(char *) "y", NULL
35723 };
35724
35725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35727 if (!SWIG_IsOK(res1)) {
35728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35729 }
35730 arg1 = reinterpret_cast< wxWindow * >(argp1);
35731 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35732 int val;
35733 int ecode = SWIG_AsVal_int(obj1, &val);
35734 if (!SWIG_IsOK(ecode)) {
35735 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35736 }
35737 temp2 = static_cast< int >(val);
35738 arg2 = &temp2;
35739 res2 = SWIG_AddTmpMask(ecode);
35740 }
35741 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35742 int val;
35743 int ecode = SWIG_AsVal_int(obj2, &val);
35744 if (!SWIG_IsOK(ecode)) {
35745 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35746 }
35747 temp3 = static_cast< int >(val);
35748 arg3 = &temp3;
35749 res3 = SWIG_AddTmpMask(ecode);
35750 }
35751 {
35752 PyThreadState* __tstate = wxPyBeginAllowThreads();
35753 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35754 wxPyEndAllowThreads(__tstate);
35755 if (PyErr_Occurred()) SWIG_fail;
35756 }
35757 resultobj = SWIG_Py_Void();
35758 if (SWIG_IsTmpObj(res2)) {
35759 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35760 } else {
35761 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35762 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35763 }
35764 if (SWIG_IsTmpObj(res3)) {
35765 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35766 } else {
35767 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35768 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35769 }
35770 return resultobj;
35771 fail:
35772 return NULL;
35773 }
35774
35775
35776 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35777 PyObject *resultobj = 0;
35778 wxWindow *arg1 = (wxWindow *) 0 ;
35779 wxPoint *arg2 = 0 ;
35780 wxPoint result;
35781 void *argp1 = 0 ;
35782 int res1 = 0 ;
35783 wxPoint temp2 ;
35784 PyObject * obj0 = 0 ;
35785 PyObject * obj1 = 0 ;
35786 char * kwnames[] = {
35787 (char *) "self",(char *) "pt", NULL
35788 };
35789
35790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35792 if (!SWIG_IsOK(res1)) {
35793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35794 }
35795 arg1 = reinterpret_cast< wxWindow * >(argp1);
35796 {
35797 arg2 = &temp2;
35798 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35799 }
35800 {
35801 PyThreadState* __tstate = wxPyBeginAllowThreads();
35802 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35803 wxPyEndAllowThreads(__tstate);
35804 if (PyErr_Occurred()) SWIG_fail;
35805 }
35806 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35807 return resultobj;
35808 fail:
35809 return NULL;
35810 }
35811
35812
35813 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35814 PyObject *resultobj = 0;
35815 wxWindow *arg1 = (wxWindow *) 0 ;
35816 wxPoint *arg2 = 0 ;
35817 wxPoint result;
35818 void *argp1 = 0 ;
35819 int res1 = 0 ;
35820 wxPoint temp2 ;
35821 PyObject * obj0 = 0 ;
35822 PyObject * obj1 = 0 ;
35823 char * kwnames[] = {
35824 (char *) "self",(char *) "pt", NULL
35825 };
35826
35827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35829 if (!SWIG_IsOK(res1)) {
35830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35831 }
35832 arg1 = reinterpret_cast< wxWindow * >(argp1);
35833 {
35834 arg2 = &temp2;
35835 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35836 }
35837 {
35838 PyThreadState* __tstate = wxPyBeginAllowThreads();
35839 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35840 wxPyEndAllowThreads(__tstate);
35841 if (PyErr_Occurred()) SWIG_fail;
35842 }
35843 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35844 return resultobj;
35845 fail:
35846 return NULL;
35847 }
35848
35849
35850 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35851 PyObject *resultobj = 0;
35852 wxWindow *arg1 = (wxWindow *) 0 ;
35853 int arg2 ;
35854 int arg3 ;
35855 wxHitTest result;
35856 void *argp1 = 0 ;
35857 int res1 = 0 ;
35858 int val2 ;
35859 int ecode2 = 0 ;
35860 int val3 ;
35861 int ecode3 = 0 ;
35862 PyObject * obj0 = 0 ;
35863 PyObject * obj1 = 0 ;
35864 PyObject * obj2 = 0 ;
35865 char * kwnames[] = {
35866 (char *) "self",(char *) "x",(char *) "y", NULL
35867 };
35868
35869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35871 if (!SWIG_IsOK(res1)) {
35872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35873 }
35874 arg1 = reinterpret_cast< wxWindow * >(argp1);
35875 ecode2 = SWIG_AsVal_int(obj1, &val2);
35876 if (!SWIG_IsOK(ecode2)) {
35877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35878 }
35879 arg2 = static_cast< int >(val2);
35880 ecode3 = SWIG_AsVal_int(obj2, &val3);
35881 if (!SWIG_IsOK(ecode3)) {
35882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35883 }
35884 arg3 = static_cast< int >(val3);
35885 {
35886 PyThreadState* __tstate = wxPyBeginAllowThreads();
35887 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35888 wxPyEndAllowThreads(__tstate);
35889 if (PyErr_Occurred()) SWIG_fail;
35890 }
35891 resultobj = SWIG_From_int(static_cast< int >(result));
35892 return resultobj;
35893 fail:
35894 return NULL;
35895 }
35896
35897
35898 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35899 PyObject *resultobj = 0;
35900 wxWindow *arg1 = (wxWindow *) 0 ;
35901 wxPoint *arg2 = 0 ;
35902 wxHitTest result;
35903 void *argp1 = 0 ;
35904 int res1 = 0 ;
35905 wxPoint temp2 ;
35906 PyObject * obj0 = 0 ;
35907 PyObject * obj1 = 0 ;
35908 char * kwnames[] = {
35909 (char *) "self",(char *) "pt", NULL
35910 };
35911
35912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35914 if (!SWIG_IsOK(res1)) {
35915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35916 }
35917 arg1 = reinterpret_cast< wxWindow * >(argp1);
35918 {
35919 arg2 = &temp2;
35920 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35921 }
35922 {
35923 PyThreadState* __tstate = wxPyBeginAllowThreads();
35924 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35925 wxPyEndAllowThreads(__tstate);
35926 if (PyErr_Occurred()) SWIG_fail;
35927 }
35928 resultobj = SWIG_From_int(static_cast< int >(result));
35929 return resultobj;
35930 fail:
35931 return NULL;
35932 }
35933
35934
35935 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35936 PyObject *resultobj = 0;
35937 wxWindow *arg1 = (wxWindow *) 0 ;
35938 long arg2 ;
35939 wxBorder result;
35940 void *argp1 = 0 ;
35941 int res1 = 0 ;
35942 long val2 ;
35943 int ecode2 = 0 ;
35944
35945 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35947 if (!SWIG_IsOK(res1)) {
35948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35949 }
35950 arg1 = reinterpret_cast< wxWindow * >(argp1);
35951 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35952 if (!SWIG_IsOK(ecode2)) {
35953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35954 }
35955 arg2 = static_cast< long >(val2);
35956 {
35957 PyThreadState* __tstate = wxPyBeginAllowThreads();
35958 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35959 wxPyEndAllowThreads(__tstate);
35960 if (PyErr_Occurred()) SWIG_fail;
35961 }
35962 resultobj = SWIG_From_int(static_cast< int >(result));
35963 return resultobj;
35964 fail:
35965 return NULL;
35966 }
35967
35968
35969 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35970 PyObject *resultobj = 0;
35971 wxWindow *arg1 = (wxWindow *) 0 ;
35972 wxBorder result;
35973 void *argp1 = 0 ;
35974 int res1 = 0 ;
35975
35976 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35978 if (!SWIG_IsOK(res1)) {
35979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35980 }
35981 arg1 = reinterpret_cast< wxWindow * >(argp1);
35982 {
35983 PyThreadState* __tstate = wxPyBeginAllowThreads();
35984 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35985 wxPyEndAllowThreads(__tstate);
35986 if (PyErr_Occurred()) SWIG_fail;
35987 }
35988 resultobj = SWIG_From_int(static_cast< int >(result));
35989 return resultobj;
35990 fail:
35991 return NULL;
35992 }
35993
35994
35995 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35996 int argc;
35997 PyObject *argv[3];
35998
35999 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36000 --argc;
36001 if (argc == 1) {
36002 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36003 }
36004 if (argc == 2) {
36005 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36006 }
36007
36008 fail:
36009 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36010 return NULL;
36011 }
36012
36013
36014 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36015 PyObject *resultobj = 0;
36016 wxWindow *arg1 = (wxWindow *) 0 ;
36017 long arg2 = (long) wxUPDATE_UI_NONE ;
36018 void *argp1 = 0 ;
36019 int res1 = 0 ;
36020 long val2 ;
36021 int ecode2 = 0 ;
36022 PyObject * obj0 = 0 ;
36023 PyObject * obj1 = 0 ;
36024 char * kwnames[] = {
36025 (char *) "self",(char *) "flags", NULL
36026 };
36027
36028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36030 if (!SWIG_IsOK(res1)) {
36031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36032 }
36033 arg1 = reinterpret_cast< wxWindow * >(argp1);
36034 if (obj1) {
36035 ecode2 = SWIG_AsVal_long(obj1, &val2);
36036 if (!SWIG_IsOK(ecode2)) {
36037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36038 }
36039 arg2 = static_cast< long >(val2);
36040 }
36041 {
36042 PyThreadState* __tstate = wxPyBeginAllowThreads();
36043 (arg1)->UpdateWindowUI(arg2);
36044 wxPyEndAllowThreads(__tstate);
36045 if (PyErr_Occurred()) SWIG_fail;
36046 }
36047 resultobj = SWIG_Py_Void();
36048 return resultobj;
36049 fail:
36050 return NULL;
36051 }
36052
36053
36054 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36055 PyObject *resultobj = 0;
36056 wxWindow *arg1 = (wxWindow *) 0 ;
36057 wxMenu *arg2 = (wxMenu *) 0 ;
36058 int arg3 = (int) -1 ;
36059 int arg4 = (int) -1 ;
36060 bool result;
36061 void *argp1 = 0 ;
36062 int res1 = 0 ;
36063 void *argp2 = 0 ;
36064 int res2 = 0 ;
36065 int val3 ;
36066 int ecode3 = 0 ;
36067 int val4 ;
36068 int ecode4 = 0 ;
36069 PyObject * obj0 = 0 ;
36070 PyObject * obj1 = 0 ;
36071 PyObject * obj2 = 0 ;
36072 PyObject * obj3 = 0 ;
36073 char * kwnames[] = {
36074 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36075 };
36076
36077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36079 if (!SWIG_IsOK(res1)) {
36080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36081 }
36082 arg1 = reinterpret_cast< wxWindow * >(argp1);
36083 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36084 if (!SWIG_IsOK(res2)) {
36085 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36086 }
36087 arg2 = reinterpret_cast< wxMenu * >(argp2);
36088 if (obj2) {
36089 ecode3 = SWIG_AsVal_int(obj2, &val3);
36090 if (!SWIG_IsOK(ecode3)) {
36091 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36092 }
36093 arg3 = static_cast< int >(val3);
36094 }
36095 if (obj3) {
36096 ecode4 = SWIG_AsVal_int(obj3, &val4);
36097 if (!SWIG_IsOK(ecode4)) {
36098 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36099 }
36100 arg4 = static_cast< int >(val4);
36101 }
36102 {
36103 PyThreadState* __tstate = wxPyBeginAllowThreads();
36104 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36105 wxPyEndAllowThreads(__tstate);
36106 if (PyErr_Occurred()) SWIG_fail;
36107 }
36108 {
36109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36110 }
36111 return resultobj;
36112 fail:
36113 return NULL;
36114 }
36115
36116
36117 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36118 PyObject *resultobj = 0;
36119 wxWindow *arg1 = (wxWindow *) 0 ;
36120 wxMenu *arg2 = (wxMenu *) 0 ;
36121 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36122 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36123 bool result;
36124 void *argp1 = 0 ;
36125 int res1 = 0 ;
36126 void *argp2 = 0 ;
36127 int res2 = 0 ;
36128 wxPoint temp3 ;
36129 PyObject * obj0 = 0 ;
36130 PyObject * obj1 = 0 ;
36131 PyObject * obj2 = 0 ;
36132 char * kwnames[] = {
36133 (char *) "self",(char *) "menu",(char *) "pos", NULL
36134 };
36135
36136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36138 if (!SWIG_IsOK(res1)) {
36139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36140 }
36141 arg1 = reinterpret_cast< wxWindow * >(argp1);
36142 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36143 if (!SWIG_IsOK(res2)) {
36144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36145 }
36146 arg2 = reinterpret_cast< wxMenu * >(argp2);
36147 if (obj2) {
36148 {
36149 arg3 = &temp3;
36150 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36151 }
36152 }
36153 {
36154 PyThreadState* __tstate = wxPyBeginAllowThreads();
36155 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36156 wxPyEndAllowThreads(__tstate);
36157 if (PyErr_Occurred()) SWIG_fail;
36158 }
36159 {
36160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36161 }
36162 return resultobj;
36163 fail:
36164 return NULL;
36165 }
36166
36167
36168 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36169 PyObject *resultobj = 0;
36170 wxWindow *arg1 = (wxWindow *) 0 ;
36171 long result;
36172 void *argp1 = 0 ;
36173 int res1 = 0 ;
36174 PyObject *swig_obj[1] ;
36175
36176 if (!args) SWIG_fail;
36177 swig_obj[0] = args;
36178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36179 if (!SWIG_IsOK(res1)) {
36180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36181 }
36182 arg1 = reinterpret_cast< wxWindow * >(argp1);
36183 {
36184 PyThreadState* __tstate = wxPyBeginAllowThreads();
36185 result = (long)wxWindow_GetHandle(arg1);
36186 wxPyEndAllowThreads(__tstate);
36187 if (PyErr_Occurred()) SWIG_fail;
36188 }
36189 resultobj = SWIG_From_long(static_cast< long >(result));
36190 return resultobj;
36191 fail:
36192 return NULL;
36193 }
36194
36195
36196 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36197 PyObject *resultobj = 0;
36198 wxWindow *arg1 = (wxWindow *) 0 ;
36199 long arg2 ;
36200 void *argp1 = 0 ;
36201 int res1 = 0 ;
36202 long val2 ;
36203 int ecode2 = 0 ;
36204 PyObject * obj0 = 0 ;
36205 PyObject * obj1 = 0 ;
36206 char * kwnames[] = {
36207 (char *) "self",(char *) "handle", NULL
36208 };
36209
36210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36212 if (!SWIG_IsOK(res1)) {
36213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36214 }
36215 arg1 = reinterpret_cast< wxWindow * >(argp1);
36216 ecode2 = SWIG_AsVal_long(obj1, &val2);
36217 if (!SWIG_IsOK(ecode2)) {
36218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36219 }
36220 arg2 = static_cast< long >(val2);
36221 {
36222 PyThreadState* __tstate = wxPyBeginAllowThreads();
36223 wxWindow_AssociateHandle(arg1,arg2);
36224 wxPyEndAllowThreads(__tstate);
36225 if (PyErr_Occurred()) SWIG_fail;
36226 }
36227 resultobj = SWIG_Py_Void();
36228 return resultobj;
36229 fail:
36230 return NULL;
36231 }
36232
36233
36234 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36235 PyObject *resultobj = 0;
36236 wxWindow *arg1 = (wxWindow *) 0 ;
36237 void *argp1 = 0 ;
36238 int res1 = 0 ;
36239 PyObject *swig_obj[1] ;
36240
36241 if (!args) SWIG_fail;
36242 swig_obj[0] = args;
36243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36244 if (!SWIG_IsOK(res1)) {
36245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36246 }
36247 arg1 = reinterpret_cast< wxWindow * >(argp1);
36248 {
36249 PyThreadState* __tstate = wxPyBeginAllowThreads();
36250 (arg1)->DissociateHandle();
36251 wxPyEndAllowThreads(__tstate);
36252 if (PyErr_Occurred()) SWIG_fail;
36253 }
36254 resultobj = SWIG_Py_Void();
36255 return resultobj;
36256 fail:
36257 return NULL;
36258 }
36259
36260
36261 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36262 PyObject *resultobj = 0;
36263 wxWindow *arg1 = (wxWindow *) 0 ;
36264 int arg2 ;
36265 bool result;
36266 void *argp1 = 0 ;
36267 int res1 = 0 ;
36268 int val2 ;
36269 int ecode2 = 0 ;
36270 PyObject * obj0 = 0 ;
36271 PyObject * obj1 = 0 ;
36272 char * kwnames[] = {
36273 (char *) "self",(char *) "orient", NULL
36274 };
36275
36276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36278 if (!SWIG_IsOK(res1)) {
36279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36280 }
36281 arg1 = reinterpret_cast< wxWindow * >(argp1);
36282 ecode2 = SWIG_AsVal_int(obj1, &val2);
36283 if (!SWIG_IsOK(ecode2)) {
36284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36285 }
36286 arg2 = static_cast< int >(val2);
36287 {
36288 PyThreadState* __tstate = wxPyBeginAllowThreads();
36289 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36290 wxPyEndAllowThreads(__tstate);
36291 if (PyErr_Occurred()) SWIG_fail;
36292 }
36293 {
36294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36295 }
36296 return resultobj;
36297 fail:
36298 return NULL;
36299 }
36300
36301
36302 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36303 PyObject *resultobj = 0;
36304 wxWindow *arg1 = (wxWindow *) 0 ;
36305 int arg2 ;
36306 int arg3 ;
36307 int arg4 ;
36308 int arg5 ;
36309 bool arg6 = (bool) true ;
36310 void *argp1 = 0 ;
36311 int res1 = 0 ;
36312 int val2 ;
36313 int ecode2 = 0 ;
36314 int val3 ;
36315 int ecode3 = 0 ;
36316 int val4 ;
36317 int ecode4 = 0 ;
36318 int val5 ;
36319 int ecode5 = 0 ;
36320 bool val6 ;
36321 int ecode6 = 0 ;
36322 PyObject * obj0 = 0 ;
36323 PyObject * obj1 = 0 ;
36324 PyObject * obj2 = 0 ;
36325 PyObject * obj3 = 0 ;
36326 PyObject * obj4 = 0 ;
36327 PyObject * obj5 = 0 ;
36328 char * kwnames[] = {
36329 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36330 };
36331
36332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36334 if (!SWIG_IsOK(res1)) {
36335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36336 }
36337 arg1 = reinterpret_cast< wxWindow * >(argp1);
36338 ecode2 = SWIG_AsVal_int(obj1, &val2);
36339 if (!SWIG_IsOK(ecode2)) {
36340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36341 }
36342 arg2 = static_cast< int >(val2);
36343 ecode3 = SWIG_AsVal_int(obj2, &val3);
36344 if (!SWIG_IsOK(ecode3)) {
36345 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36346 }
36347 arg3 = static_cast< int >(val3);
36348 ecode4 = SWIG_AsVal_int(obj3, &val4);
36349 if (!SWIG_IsOK(ecode4)) {
36350 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36351 }
36352 arg4 = static_cast< int >(val4);
36353 ecode5 = SWIG_AsVal_int(obj4, &val5);
36354 if (!SWIG_IsOK(ecode5)) {
36355 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36356 }
36357 arg5 = static_cast< int >(val5);
36358 if (obj5) {
36359 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36360 if (!SWIG_IsOK(ecode6)) {
36361 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36362 }
36363 arg6 = static_cast< bool >(val6);
36364 }
36365 {
36366 PyThreadState* __tstate = wxPyBeginAllowThreads();
36367 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36368 wxPyEndAllowThreads(__tstate);
36369 if (PyErr_Occurred()) SWIG_fail;
36370 }
36371 resultobj = SWIG_Py_Void();
36372 return resultobj;
36373 fail:
36374 return NULL;
36375 }
36376
36377
36378 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36379 PyObject *resultobj = 0;
36380 wxWindow *arg1 = (wxWindow *) 0 ;
36381 int arg2 ;
36382 int arg3 ;
36383 bool arg4 = (bool) true ;
36384 void *argp1 = 0 ;
36385 int res1 = 0 ;
36386 int val2 ;
36387 int ecode2 = 0 ;
36388 int val3 ;
36389 int ecode3 = 0 ;
36390 bool val4 ;
36391 int ecode4 = 0 ;
36392 PyObject * obj0 = 0 ;
36393 PyObject * obj1 = 0 ;
36394 PyObject * obj2 = 0 ;
36395 PyObject * obj3 = 0 ;
36396 char * kwnames[] = {
36397 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36398 };
36399
36400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36402 if (!SWIG_IsOK(res1)) {
36403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36404 }
36405 arg1 = reinterpret_cast< wxWindow * >(argp1);
36406 ecode2 = SWIG_AsVal_int(obj1, &val2);
36407 if (!SWIG_IsOK(ecode2)) {
36408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36409 }
36410 arg2 = static_cast< int >(val2);
36411 ecode3 = SWIG_AsVal_int(obj2, &val3);
36412 if (!SWIG_IsOK(ecode3)) {
36413 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36414 }
36415 arg3 = static_cast< int >(val3);
36416 if (obj3) {
36417 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36418 if (!SWIG_IsOK(ecode4)) {
36419 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36420 }
36421 arg4 = static_cast< bool >(val4);
36422 }
36423 {
36424 PyThreadState* __tstate = wxPyBeginAllowThreads();
36425 (arg1)->SetScrollPos(arg2,arg3,arg4);
36426 wxPyEndAllowThreads(__tstate);
36427 if (PyErr_Occurred()) SWIG_fail;
36428 }
36429 resultobj = SWIG_Py_Void();
36430 return resultobj;
36431 fail:
36432 return NULL;
36433 }
36434
36435
36436 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36437 PyObject *resultobj = 0;
36438 wxWindow *arg1 = (wxWindow *) 0 ;
36439 int arg2 ;
36440 int result;
36441 void *argp1 = 0 ;
36442 int res1 = 0 ;
36443 int val2 ;
36444 int ecode2 = 0 ;
36445 PyObject * obj0 = 0 ;
36446 PyObject * obj1 = 0 ;
36447 char * kwnames[] = {
36448 (char *) "self",(char *) "orientation", NULL
36449 };
36450
36451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36453 if (!SWIG_IsOK(res1)) {
36454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36455 }
36456 arg1 = reinterpret_cast< wxWindow * >(argp1);
36457 ecode2 = SWIG_AsVal_int(obj1, &val2);
36458 if (!SWIG_IsOK(ecode2)) {
36459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36460 }
36461 arg2 = static_cast< int >(val2);
36462 {
36463 PyThreadState* __tstate = wxPyBeginAllowThreads();
36464 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36465 wxPyEndAllowThreads(__tstate);
36466 if (PyErr_Occurred()) SWIG_fail;
36467 }
36468 resultobj = SWIG_From_int(static_cast< int >(result));
36469 return resultobj;
36470 fail:
36471 return NULL;
36472 }
36473
36474
36475 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36476 PyObject *resultobj = 0;
36477 wxWindow *arg1 = (wxWindow *) 0 ;
36478 int arg2 ;
36479 int result;
36480 void *argp1 = 0 ;
36481 int res1 = 0 ;
36482 int val2 ;
36483 int ecode2 = 0 ;
36484 PyObject * obj0 = 0 ;
36485 PyObject * obj1 = 0 ;
36486 char * kwnames[] = {
36487 (char *) "self",(char *) "orientation", NULL
36488 };
36489
36490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36492 if (!SWIG_IsOK(res1)) {
36493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36494 }
36495 arg1 = reinterpret_cast< wxWindow * >(argp1);
36496 ecode2 = SWIG_AsVal_int(obj1, &val2);
36497 if (!SWIG_IsOK(ecode2)) {
36498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36499 }
36500 arg2 = static_cast< int >(val2);
36501 {
36502 PyThreadState* __tstate = wxPyBeginAllowThreads();
36503 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36504 wxPyEndAllowThreads(__tstate);
36505 if (PyErr_Occurred()) SWIG_fail;
36506 }
36507 resultobj = SWIG_From_int(static_cast< int >(result));
36508 return resultobj;
36509 fail:
36510 return NULL;
36511 }
36512
36513
36514 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36515 PyObject *resultobj = 0;
36516 wxWindow *arg1 = (wxWindow *) 0 ;
36517 int arg2 ;
36518 int result;
36519 void *argp1 = 0 ;
36520 int res1 = 0 ;
36521 int val2 ;
36522 int ecode2 = 0 ;
36523 PyObject * obj0 = 0 ;
36524 PyObject * obj1 = 0 ;
36525 char * kwnames[] = {
36526 (char *) "self",(char *) "orientation", NULL
36527 };
36528
36529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36531 if (!SWIG_IsOK(res1)) {
36532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36533 }
36534 arg1 = reinterpret_cast< wxWindow * >(argp1);
36535 ecode2 = SWIG_AsVal_int(obj1, &val2);
36536 if (!SWIG_IsOK(ecode2)) {
36537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36538 }
36539 arg2 = static_cast< int >(val2);
36540 {
36541 PyThreadState* __tstate = wxPyBeginAllowThreads();
36542 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
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_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36554 PyObject *resultobj = 0;
36555 wxWindow *arg1 = (wxWindow *) 0 ;
36556 int arg2 ;
36557 int arg3 ;
36558 wxRect *arg4 = (wxRect *) NULL ;
36559 void *argp1 = 0 ;
36560 int res1 = 0 ;
36561 int val2 ;
36562 int ecode2 = 0 ;
36563 int val3 ;
36564 int ecode3 = 0 ;
36565 void *argp4 = 0 ;
36566 int res4 = 0 ;
36567 PyObject * obj0 = 0 ;
36568 PyObject * obj1 = 0 ;
36569 PyObject * obj2 = 0 ;
36570 PyObject * obj3 = 0 ;
36571 char * kwnames[] = {
36572 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36573 };
36574
36575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36577 if (!SWIG_IsOK(res1)) {
36578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36579 }
36580 arg1 = reinterpret_cast< wxWindow * >(argp1);
36581 ecode2 = SWIG_AsVal_int(obj1, &val2);
36582 if (!SWIG_IsOK(ecode2)) {
36583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36584 }
36585 arg2 = static_cast< int >(val2);
36586 ecode3 = SWIG_AsVal_int(obj2, &val3);
36587 if (!SWIG_IsOK(ecode3)) {
36588 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36589 }
36590 arg3 = static_cast< int >(val3);
36591 if (obj3) {
36592 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36593 if (!SWIG_IsOK(res4)) {
36594 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36595 }
36596 arg4 = reinterpret_cast< wxRect * >(argp4);
36597 }
36598 {
36599 PyThreadState* __tstate = wxPyBeginAllowThreads();
36600 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36601 wxPyEndAllowThreads(__tstate);
36602 if (PyErr_Occurred()) SWIG_fail;
36603 }
36604 resultobj = SWIG_Py_Void();
36605 return resultobj;
36606 fail:
36607 return NULL;
36608 }
36609
36610
36611 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36612 PyObject *resultobj = 0;
36613 wxWindow *arg1 = (wxWindow *) 0 ;
36614 int arg2 ;
36615 bool result;
36616 void *argp1 = 0 ;
36617 int res1 = 0 ;
36618 int val2 ;
36619 int ecode2 = 0 ;
36620 PyObject * obj0 = 0 ;
36621 PyObject * obj1 = 0 ;
36622 char * kwnames[] = {
36623 (char *) "self",(char *) "lines", NULL
36624 };
36625
36626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36628 if (!SWIG_IsOK(res1)) {
36629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36630 }
36631 arg1 = reinterpret_cast< wxWindow * >(argp1);
36632 ecode2 = SWIG_AsVal_int(obj1, &val2);
36633 if (!SWIG_IsOK(ecode2)) {
36634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36635 }
36636 arg2 = static_cast< int >(val2);
36637 {
36638 PyThreadState* __tstate = wxPyBeginAllowThreads();
36639 result = (bool)(arg1)->ScrollLines(arg2);
36640 wxPyEndAllowThreads(__tstate);
36641 if (PyErr_Occurred()) SWIG_fail;
36642 }
36643 {
36644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36645 }
36646 return resultobj;
36647 fail:
36648 return NULL;
36649 }
36650
36651
36652 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36653 PyObject *resultobj = 0;
36654 wxWindow *arg1 = (wxWindow *) 0 ;
36655 int arg2 ;
36656 bool result;
36657 void *argp1 = 0 ;
36658 int res1 = 0 ;
36659 int val2 ;
36660 int ecode2 = 0 ;
36661 PyObject * obj0 = 0 ;
36662 PyObject * obj1 = 0 ;
36663 char * kwnames[] = {
36664 (char *) "self",(char *) "pages", NULL
36665 };
36666
36667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36669 if (!SWIG_IsOK(res1)) {
36670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36671 }
36672 arg1 = reinterpret_cast< wxWindow * >(argp1);
36673 ecode2 = SWIG_AsVal_int(obj1, &val2);
36674 if (!SWIG_IsOK(ecode2)) {
36675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36676 }
36677 arg2 = static_cast< int >(val2);
36678 {
36679 PyThreadState* __tstate = wxPyBeginAllowThreads();
36680 result = (bool)(arg1)->ScrollPages(arg2);
36681 wxPyEndAllowThreads(__tstate);
36682 if (PyErr_Occurred()) SWIG_fail;
36683 }
36684 {
36685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36686 }
36687 return resultobj;
36688 fail:
36689 return NULL;
36690 }
36691
36692
36693 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36694 PyObject *resultobj = 0;
36695 wxWindow *arg1 = (wxWindow *) 0 ;
36696 bool result;
36697 void *argp1 = 0 ;
36698 int res1 = 0 ;
36699 PyObject *swig_obj[1] ;
36700
36701 if (!args) SWIG_fail;
36702 swig_obj[0] = args;
36703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36704 if (!SWIG_IsOK(res1)) {
36705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36706 }
36707 arg1 = reinterpret_cast< wxWindow * >(argp1);
36708 {
36709 PyThreadState* __tstate = wxPyBeginAllowThreads();
36710 result = (bool)(arg1)->LineUp();
36711 wxPyEndAllowThreads(__tstate);
36712 if (PyErr_Occurred()) SWIG_fail;
36713 }
36714 {
36715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36716 }
36717 return resultobj;
36718 fail:
36719 return NULL;
36720 }
36721
36722
36723 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36724 PyObject *resultobj = 0;
36725 wxWindow *arg1 = (wxWindow *) 0 ;
36726 bool result;
36727 void *argp1 = 0 ;
36728 int res1 = 0 ;
36729 PyObject *swig_obj[1] ;
36730
36731 if (!args) SWIG_fail;
36732 swig_obj[0] = args;
36733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36734 if (!SWIG_IsOK(res1)) {
36735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36736 }
36737 arg1 = reinterpret_cast< wxWindow * >(argp1);
36738 {
36739 PyThreadState* __tstate = wxPyBeginAllowThreads();
36740 result = (bool)(arg1)->LineDown();
36741 wxPyEndAllowThreads(__tstate);
36742 if (PyErr_Occurred()) SWIG_fail;
36743 }
36744 {
36745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36746 }
36747 return resultobj;
36748 fail:
36749 return NULL;
36750 }
36751
36752
36753 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36754 PyObject *resultobj = 0;
36755 wxWindow *arg1 = (wxWindow *) 0 ;
36756 bool result;
36757 void *argp1 = 0 ;
36758 int res1 = 0 ;
36759 PyObject *swig_obj[1] ;
36760
36761 if (!args) SWIG_fail;
36762 swig_obj[0] = args;
36763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36764 if (!SWIG_IsOK(res1)) {
36765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36766 }
36767 arg1 = reinterpret_cast< wxWindow * >(argp1);
36768 {
36769 PyThreadState* __tstate = wxPyBeginAllowThreads();
36770 result = (bool)(arg1)->PageUp();
36771 wxPyEndAllowThreads(__tstate);
36772 if (PyErr_Occurred()) SWIG_fail;
36773 }
36774 {
36775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36776 }
36777 return resultobj;
36778 fail:
36779 return NULL;
36780 }
36781
36782
36783 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36784 PyObject *resultobj = 0;
36785 wxWindow *arg1 = (wxWindow *) 0 ;
36786 bool result;
36787 void *argp1 = 0 ;
36788 int res1 = 0 ;
36789 PyObject *swig_obj[1] ;
36790
36791 if (!args) SWIG_fail;
36792 swig_obj[0] = args;
36793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36794 if (!SWIG_IsOK(res1)) {
36795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36796 }
36797 arg1 = reinterpret_cast< wxWindow * >(argp1);
36798 {
36799 PyThreadState* __tstate = wxPyBeginAllowThreads();
36800 result = (bool)(arg1)->PageDown();
36801 wxPyEndAllowThreads(__tstate);
36802 if (PyErr_Occurred()) SWIG_fail;
36803 }
36804 {
36805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36806 }
36807 return resultobj;
36808 fail:
36809 return NULL;
36810 }
36811
36812
36813 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36814 PyObject *resultobj = 0;
36815 wxWindow *arg1 = (wxWindow *) 0 ;
36816 wxString *arg2 = 0 ;
36817 void *argp1 = 0 ;
36818 int res1 = 0 ;
36819 bool temp2 = false ;
36820 PyObject * obj0 = 0 ;
36821 PyObject * obj1 = 0 ;
36822 char * kwnames[] = {
36823 (char *) "self",(char *) "text", NULL
36824 };
36825
36826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36828 if (!SWIG_IsOK(res1)) {
36829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36830 }
36831 arg1 = reinterpret_cast< wxWindow * >(argp1);
36832 {
36833 arg2 = wxString_in_helper(obj1);
36834 if (arg2 == NULL) SWIG_fail;
36835 temp2 = true;
36836 }
36837 {
36838 PyThreadState* __tstate = wxPyBeginAllowThreads();
36839 (arg1)->SetHelpText((wxString const &)*arg2);
36840 wxPyEndAllowThreads(__tstate);
36841 if (PyErr_Occurred()) SWIG_fail;
36842 }
36843 resultobj = SWIG_Py_Void();
36844 {
36845 if (temp2)
36846 delete arg2;
36847 }
36848 return resultobj;
36849 fail:
36850 {
36851 if (temp2)
36852 delete arg2;
36853 }
36854 return NULL;
36855 }
36856
36857
36858 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36859 PyObject *resultobj = 0;
36860 wxWindow *arg1 = (wxWindow *) 0 ;
36861 wxString *arg2 = 0 ;
36862 void *argp1 = 0 ;
36863 int res1 = 0 ;
36864 bool temp2 = false ;
36865 PyObject * obj0 = 0 ;
36866 PyObject * obj1 = 0 ;
36867 char * kwnames[] = {
36868 (char *) "self",(char *) "text", NULL
36869 };
36870
36871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36873 if (!SWIG_IsOK(res1)) {
36874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36875 }
36876 arg1 = reinterpret_cast< wxWindow * >(argp1);
36877 {
36878 arg2 = wxString_in_helper(obj1);
36879 if (arg2 == NULL) SWIG_fail;
36880 temp2 = true;
36881 }
36882 {
36883 PyThreadState* __tstate = wxPyBeginAllowThreads();
36884 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36885 wxPyEndAllowThreads(__tstate);
36886 if (PyErr_Occurred()) SWIG_fail;
36887 }
36888 resultobj = SWIG_Py_Void();
36889 {
36890 if (temp2)
36891 delete arg2;
36892 }
36893 return resultobj;
36894 fail:
36895 {
36896 if (temp2)
36897 delete arg2;
36898 }
36899 return NULL;
36900 }
36901
36902
36903 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36904 PyObject *resultobj = 0;
36905 wxWindow *arg1 = (wxWindow *) 0 ;
36906 wxPoint *arg2 = 0 ;
36907 wxHelpEvent::Origin arg3 ;
36908 wxString result;
36909 void *argp1 = 0 ;
36910 int res1 = 0 ;
36911 wxPoint temp2 ;
36912 void *argp3 ;
36913 int res3 = 0 ;
36914 PyObject * obj0 = 0 ;
36915 PyObject * obj1 = 0 ;
36916 PyObject * obj2 = 0 ;
36917 char * kwnames[] = {
36918 (char *) "self",(char *) "pt",(char *) "origin", NULL
36919 };
36920
36921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36923 if (!SWIG_IsOK(res1)) {
36924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
36925 }
36926 arg1 = reinterpret_cast< wxWindow * >(argp1);
36927 {
36928 arg2 = &temp2;
36929 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36930 }
36931 {
36932 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
36933 if (!SWIG_IsOK(res3)) {
36934 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
36935 }
36936 if (!argp3) {
36937 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
36938 } else {
36939 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
36940 arg3 = *temp;
36941 if (SWIG_IsNewObj(res3)) delete temp;
36942 }
36943 }
36944 {
36945 PyThreadState* __tstate = wxPyBeginAllowThreads();
36946 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
36947 wxPyEndAllowThreads(__tstate);
36948 if (PyErr_Occurred()) SWIG_fail;
36949 }
36950 {
36951 #if wxUSE_UNICODE
36952 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36953 #else
36954 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36955 #endif
36956 }
36957 return resultobj;
36958 fail:
36959 return NULL;
36960 }
36961
36962
36963 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36964 PyObject *resultobj = 0;
36965 wxWindow *arg1 = (wxWindow *) 0 ;
36966 wxString result;
36967 void *argp1 = 0 ;
36968 int res1 = 0 ;
36969 PyObject *swig_obj[1] ;
36970
36971 if (!args) SWIG_fail;
36972 swig_obj[0] = args;
36973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36974 if (!SWIG_IsOK(res1)) {
36975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36976 }
36977 arg1 = reinterpret_cast< wxWindow * >(argp1);
36978 {
36979 PyThreadState* __tstate = wxPyBeginAllowThreads();
36980 result = ((wxWindow const *)arg1)->GetHelpText();
36981 wxPyEndAllowThreads(__tstate);
36982 if (PyErr_Occurred()) SWIG_fail;
36983 }
36984 {
36985 #if wxUSE_UNICODE
36986 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36987 #else
36988 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36989 #endif
36990 }
36991 return resultobj;
36992 fail:
36993 return NULL;
36994 }
36995
36996
36997 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36998 PyObject *resultobj = 0;
36999 wxWindow *arg1 = (wxWindow *) 0 ;
37000 wxString *arg2 = 0 ;
37001 void *argp1 = 0 ;
37002 int res1 = 0 ;
37003 bool temp2 = false ;
37004 PyObject * obj0 = 0 ;
37005 PyObject * obj1 = 0 ;
37006 char * kwnames[] = {
37007 (char *) "self",(char *) "tip", NULL
37008 };
37009
37010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37012 if (!SWIG_IsOK(res1)) {
37013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37014 }
37015 arg1 = reinterpret_cast< wxWindow * >(argp1);
37016 {
37017 arg2 = wxString_in_helper(obj1);
37018 if (arg2 == NULL) SWIG_fail;
37019 temp2 = true;
37020 }
37021 {
37022 PyThreadState* __tstate = wxPyBeginAllowThreads();
37023 (arg1)->SetToolTip((wxString const &)*arg2);
37024 wxPyEndAllowThreads(__tstate);
37025 if (PyErr_Occurred()) SWIG_fail;
37026 }
37027 resultobj = SWIG_Py_Void();
37028 {
37029 if (temp2)
37030 delete arg2;
37031 }
37032 return resultobj;
37033 fail:
37034 {
37035 if (temp2)
37036 delete arg2;
37037 }
37038 return NULL;
37039 }
37040
37041
37042 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37043 PyObject *resultobj = 0;
37044 wxWindow *arg1 = (wxWindow *) 0 ;
37045 wxToolTip *arg2 = (wxToolTip *) 0 ;
37046 void *argp1 = 0 ;
37047 int res1 = 0 ;
37048 int res2 = 0 ;
37049 PyObject * obj0 = 0 ;
37050 PyObject * obj1 = 0 ;
37051 char * kwnames[] = {
37052 (char *) "self",(char *) "tip", NULL
37053 };
37054
37055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37057 if (!SWIG_IsOK(res1)) {
37058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37059 }
37060 arg1 = reinterpret_cast< wxWindow * >(argp1);
37061 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37062 if (!SWIG_IsOK(res2)) {
37063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37064 }
37065 {
37066 PyThreadState* __tstate = wxPyBeginAllowThreads();
37067 (arg1)->SetToolTip(arg2);
37068 wxPyEndAllowThreads(__tstate);
37069 if (PyErr_Occurred()) SWIG_fail;
37070 }
37071 resultobj = SWIG_Py_Void();
37072 return resultobj;
37073 fail:
37074 return NULL;
37075 }
37076
37077
37078 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37079 PyObject *resultobj = 0;
37080 wxWindow *arg1 = (wxWindow *) 0 ;
37081 wxToolTip *result = 0 ;
37082 void *argp1 = 0 ;
37083 int res1 = 0 ;
37084 PyObject *swig_obj[1] ;
37085
37086 if (!args) SWIG_fail;
37087 swig_obj[0] = args;
37088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37089 if (!SWIG_IsOK(res1)) {
37090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37091 }
37092 arg1 = reinterpret_cast< wxWindow * >(argp1);
37093 {
37094 PyThreadState* __tstate = wxPyBeginAllowThreads();
37095 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37096 wxPyEndAllowThreads(__tstate);
37097 if (PyErr_Occurred()) SWIG_fail;
37098 }
37099 {
37100 resultobj = wxPyMake_wxObject(result, (bool)0);
37101 }
37102 return resultobj;
37103 fail:
37104 return NULL;
37105 }
37106
37107
37108 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37109 PyObject *resultobj = 0;
37110 wxWindow *arg1 = (wxWindow *) 0 ;
37111 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37112 void *argp1 = 0 ;
37113 int res1 = 0 ;
37114 int res2 = 0 ;
37115 PyObject * obj0 = 0 ;
37116 PyObject * obj1 = 0 ;
37117 char * kwnames[] = {
37118 (char *) "self",(char *) "dropTarget", NULL
37119 };
37120
37121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37123 if (!SWIG_IsOK(res1)) {
37124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37125 }
37126 arg1 = reinterpret_cast< wxWindow * >(argp1);
37127 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37128 if (!SWIG_IsOK(res2)) {
37129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37130 }
37131 {
37132 PyThreadState* __tstate = wxPyBeginAllowThreads();
37133 (arg1)->SetDropTarget(arg2);
37134 wxPyEndAllowThreads(__tstate);
37135 if (PyErr_Occurred()) SWIG_fail;
37136 }
37137 resultobj = SWIG_Py_Void();
37138 return resultobj;
37139 fail:
37140 return NULL;
37141 }
37142
37143
37144 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37145 PyObject *resultobj = 0;
37146 wxWindow *arg1 = (wxWindow *) 0 ;
37147 wxPyDropTarget *result = 0 ;
37148 void *argp1 = 0 ;
37149 int res1 = 0 ;
37150 PyObject *swig_obj[1] ;
37151
37152 if (!args) SWIG_fail;
37153 swig_obj[0] = args;
37154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37155 if (!SWIG_IsOK(res1)) {
37156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37157 }
37158 arg1 = reinterpret_cast< wxWindow * >(argp1);
37159 {
37160 PyThreadState* __tstate = wxPyBeginAllowThreads();
37161 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37162 wxPyEndAllowThreads(__tstate);
37163 if (PyErr_Occurred()) SWIG_fail;
37164 }
37165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37166 return resultobj;
37167 fail:
37168 return NULL;
37169 }
37170
37171
37172 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37173 PyObject *resultobj = 0;
37174 wxWindow *arg1 = (wxWindow *) 0 ;
37175 bool arg2 ;
37176 void *argp1 = 0 ;
37177 int res1 = 0 ;
37178 bool val2 ;
37179 int ecode2 = 0 ;
37180 PyObject * obj0 = 0 ;
37181 PyObject * obj1 = 0 ;
37182 char * kwnames[] = {
37183 (char *) "self",(char *) "accept", NULL
37184 };
37185
37186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37188 if (!SWIG_IsOK(res1)) {
37189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37190 }
37191 arg1 = reinterpret_cast< wxWindow * >(argp1);
37192 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37193 if (!SWIG_IsOK(ecode2)) {
37194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37195 }
37196 arg2 = static_cast< bool >(val2);
37197 {
37198 PyThreadState* __tstate = wxPyBeginAllowThreads();
37199 wxWindow_DragAcceptFiles(arg1,arg2);
37200 wxPyEndAllowThreads(__tstate);
37201 if (PyErr_Occurred()) SWIG_fail;
37202 }
37203 resultobj = SWIG_Py_Void();
37204 return resultobj;
37205 fail:
37206 return NULL;
37207 }
37208
37209
37210 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37211 PyObject *resultobj = 0;
37212 wxWindow *arg1 = (wxWindow *) 0 ;
37213 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37214 void *argp1 = 0 ;
37215 int res1 = 0 ;
37216 int res2 = 0 ;
37217 PyObject * obj0 = 0 ;
37218 PyObject * obj1 = 0 ;
37219 char * kwnames[] = {
37220 (char *) "self",(char *) "constraints", NULL
37221 };
37222
37223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37225 if (!SWIG_IsOK(res1)) {
37226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37227 }
37228 arg1 = reinterpret_cast< wxWindow * >(argp1);
37229 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37230 if (!SWIG_IsOK(res2)) {
37231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37232 }
37233 {
37234 PyThreadState* __tstate = wxPyBeginAllowThreads();
37235 (arg1)->SetConstraints(arg2);
37236 wxPyEndAllowThreads(__tstate);
37237 if (PyErr_Occurred()) SWIG_fail;
37238 }
37239 resultobj = SWIG_Py_Void();
37240 return resultobj;
37241 fail:
37242 return NULL;
37243 }
37244
37245
37246 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37247 PyObject *resultobj = 0;
37248 wxWindow *arg1 = (wxWindow *) 0 ;
37249 wxLayoutConstraints *result = 0 ;
37250 void *argp1 = 0 ;
37251 int res1 = 0 ;
37252 PyObject *swig_obj[1] ;
37253
37254 if (!args) SWIG_fail;
37255 swig_obj[0] = args;
37256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37257 if (!SWIG_IsOK(res1)) {
37258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37259 }
37260 arg1 = reinterpret_cast< wxWindow * >(argp1);
37261 {
37262 PyThreadState* __tstate = wxPyBeginAllowThreads();
37263 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37264 wxPyEndAllowThreads(__tstate);
37265 if (PyErr_Occurred()) SWIG_fail;
37266 }
37267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37268 return resultobj;
37269 fail:
37270 return NULL;
37271 }
37272
37273
37274 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37275 PyObject *resultobj = 0;
37276 wxWindow *arg1 = (wxWindow *) 0 ;
37277 bool arg2 ;
37278 void *argp1 = 0 ;
37279 int res1 = 0 ;
37280 bool val2 ;
37281 int ecode2 = 0 ;
37282 PyObject * obj0 = 0 ;
37283 PyObject * obj1 = 0 ;
37284 char * kwnames[] = {
37285 (char *) "self",(char *) "autoLayout", NULL
37286 };
37287
37288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37290 if (!SWIG_IsOK(res1)) {
37291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37292 }
37293 arg1 = reinterpret_cast< wxWindow * >(argp1);
37294 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37295 if (!SWIG_IsOK(ecode2)) {
37296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37297 }
37298 arg2 = static_cast< bool >(val2);
37299 {
37300 PyThreadState* __tstate = wxPyBeginAllowThreads();
37301 (arg1)->SetAutoLayout(arg2);
37302 wxPyEndAllowThreads(__tstate);
37303 if (PyErr_Occurred()) SWIG_fail;
37304 }
37305 resultobj = SWIG_Py_Void();
37306 return resultobj;
37307 fail:
37308 return NULL;
37309 }
37310
37311
37312 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37313 PyObject *resultobj = 0;
37314 wxWindow *arg1 = (wxWindow *) 0 ;
37315 bool result;
37316 void *argp1 = 0 ;
37317 int res1 = 0 ;
37318 PyObject *swig_obj[1] ;
37319
37320 if (!args) SWIG_fail;
37321 swig_obj[0] = args;
37322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37323 if (!SWIG_IsOK(res1)) {
37324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37325 }
37326 arg1 = reinterpret_cast< wxWindow * >(argp1);
37327 {
37328 PyThreadState* __tstate = wxPyBeginAllowThreads();
37329 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37330 wxPyEndAllowThreads(__tstate);
37331 if (PyErr_Occurred()) SWIG_fail;
37332 }
37333 {
37334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37335 }
37336 return resultobj;
37337 fail:
37338 return NULL;
37339 }
37340
37341
37342 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37343 PyObject *resultobj = 0;
37344 wxWindow *arg1 = (wxWindow *) 0 ;
37345 bool result;
37346 void *argp1 = 0 ;
37347 int res1 = 0 ;
37348 PyObject *swig_obj[1] ;
37349
37350 if (!args) SWIG_fail;
37351 swig_obj[0] = args;
37352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37353 if (!SWIG_IsOK(res1)) {
37354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37355 }
37356 arg1 = reinterpret_cast< wxWindow * >(argp1);
37357 {
37358 PyThreadState* __tstate = wxPyBeginAllowThreads();
37359 result = (bool)(arg1)->Layout();
37360 wxPyEndAllowThreads(__tstate);
37361 if (PyErr_Occurred()) SWIG_fail;
37362 }
37363 {
37364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37365 }
37366 return resultobj;
37367 fail:
37368 return NULL;
37369 }
37370
37371
37372 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37373 PyObject *resultobj = 0;
37374 wxWindow *arg1 = (wxWindow *) 0 ;
37375 wxSizer *arg2 = (wxSizer *) 0 ;
37376 bool arg3 = (bool) true ;
37377 void *argp1 = 0 ;
37378 int res1 = 0 ;
37379 int res2 = 0 ;
37380 bool val3 ;
37381 int ecode3 = 0 ;
37382 PyObject * obj0 = 0 ;
37383 PyObject * obj1 = 0 ;
37384 PyObject * obj2 = 0 ;
37385 char * kwnames[] = {
37386 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37387 };
37388
37389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37391 if (!SWIG_IsOK(res1)) {
37392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37393 }
37394 arg1 = reinterpret_cast< wxWindow * >(argp1);
37395 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37396 if (!SWIG_IsOK(res2)) {
37397 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37398 }
37399 if (obj2) {
37400 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37401 if (!SWIG_IsOK(ecode3)) {
37402 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37403 }
37404 arg3 = static_cast< bool >(val3);
37405 }
37406 {
37407 PyThreadState* __tstate = wxPyBeginAllowThreads();
37408 (arg1)->SetSizer(arg2,arg3);
37409 wxPyEndAllowThreads(__tstate);
37410 if (PyErr_Occurred()) SWIG_fail;
37411 }
37412 resultobj = SWIG_Py_Void();
37413 return resultobj;
37414 fail:
37415 return NULL;
37416 }
37417
37418
37419 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37420 PyObject *resultobj = 0;
37421 wxWindow *arg1 = (wxWindow *) 0 ;
37422 wxSizer *arg2 = (wxSizer *) 0 ;
37423 bool arg3 = (bool) true ;
37424 void *argp1 = 0 ;
37425 int res1 = 0 ;
37426 int res2 = 0 ;
37427 bool val3 ;
37428 int ecode3 = 0 ;
37429 PyObject * obj0 = 0 ;
37430 PyObject * obj1 = 0 ;
37431 PyObject * obj2 = 0 ;
37432 char * kwnames[] = {
37433 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37434 };
37435
37436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37438 if (!SWIG_IsOK(res1)) {
37439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37440 }
37441 arg1 = reinterpret_cast< wxWindow * >(argp1);
37442 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37443 if (!SWIG_IsOK(res2)) {
37444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37445 }
37446 if (obj2) {
37447 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37448 if (!SWIG_IsOK(ecode3)) {
37449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37450 }
37451 arg3 = static_cast< bool >(val3);
37452 }
37453 {
37454 PyThreadState* __tstate = wxPyBeginAllowThreads();
37455 (arg1)->SetSizerAndFit(arg2,arg3);
37456 wxPyEndAllowThreads(__tstate);
37457 if (PyErr_Occurred()) SWIG_fail;
37458 }
37459 resultobj = SWIG_Py_Void();
37460 return resultobj;
37461 fail:
37462 return NULL;
37463 }
37464
37465
37466 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37467 PyObject *resultobj = 0;
37468 wxWindow *arg1 = (wxWindow *) 0 ;
37469 wxSizer *result = 0 ;
37470 void *argp1 = 0 ;
37471 int res1 = 0 ;
37472 PyObject *swig_obj[1] ;
37473
37474 if (!args) SWIG_fail;
37475 swig_obj[0] = args;
37476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37477 if (!SWIG_IsOK(res1)) {
37478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37479 }
37480 arg1 = reinterpret_cast< wxWindow * >(argp1);
37481 {
37482 PyThreadState* __tstate = wxPyBeginAllowThreads();
37483 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37484 wxPyEndAllowThreads(__tstate);
37485 if (PyErr_Occurred()) SWIG_fail;
37486 }
37487 {
37488 resultobj = wxPyMake_wxObject(result, (bool)0);
37489 }
37490 return resultobj;
37491 fail:
37492 return NULL;
37493 }
37494
37495
37496 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37497 PyObject *resultobj = 0;
37498 wxWindow *arg1 = (wxWindow *) 0 ;
37499 wxSizer *arg2 = (wxSizer *) 0 ;
37500 void *argp1 = 0 ;
37501 int res1 = 0 ;
37502 void *argp2 = 0 ;
37503 int res2 = 0 ;
37504 PyObject * obj0 = 0 ;
37505 PyObject * obj1 = 0 ;
37506 char * kwnames[] = {
37507 (char *) "self",(char *) "sizer", NULL
37508 };
37509
37510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37512 if (!SWIG_IsOK(res1)) {
37513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37514 }
37515 arg1 = reinterpret_cast< wxWindow * >(argp1);
37516 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37517 if (!SWIG_IsOK(res2)) {
37518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37519 }
37520 arg2 = reinterpret_cast< wxSizer * >(argp2);
37521 {
37522 PyThreadState* __tstate = wxPyBeginAllowThreads();
37523 (arg1)->SetContainingSizer(arg2);
37524 wxPyEndAllowThreads(__tstate);
37525 if (PyErr_Occurred()) SWIG_fail;
37526 }
37527 resultobj = SWIG_Py_Void();
37528 return resultobj;
37529 fail:
37530 return NULL;
37531 }
37532
37533
37534 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37535 PyObject *resultobj = 0;
37536 wxWindow *arg1 = (wxWindow *) 0 ;
37537 wxSizer *result = 0 ;
37538 void *argp1 = 0 ;
37539 int res1 = 0 ;
37540 PyObject *swig_obj[1] ;
37541
37542 if (!args) SWIG_fail;
37543 swig_obj[0] = args;
37544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37545 if (!SWIG_IsOK(res1)) {
37546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37547 }
37548 arg1 = reinterpret_cast< wxWindow * >(argp1);
37549 {
37550 PyThreadState* __tstate = wxPyBeginAllowThreads();
37551 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37552 wxPyEndAllowThreads(__tstate);
37553 if (PyErr_Occurred()) SWIG_fail;
37554 }
37555 {
37556 resultobj = wxPyMake_wxObject(result, (bool)0);
37557 }
37558 return resultobj;
37559 fail:
37560 return NULL;
37561 }
37562
37563
37564 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37565 PyObject *resultobj = 0;
37566 wxWindow *arg1 = (wxWindow *) 0 ;
37567 void *argp1 = 0 ;
37568 int res1 = 0 ;
37569 PyObject *swig_obj[1] ;
37570
37571 if (!args) SWIG_fail;
37572 swig_obj[0] = args;
37573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37574 if (!SWIG_IsOK(res1)) {
37575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37576 }
37577 arg1 = reinterpret_cast< wxWindow * >(argp1);
37578 {
37579 PyThreadState* __tstate = wxPyBeginAllowThreads();
37580 (arg1)->InheritAttributes();
37581 wxPyEndAllowThreads(__tstate);
37582 if (PyErr_Occurred()) SWIG_fail;
37583 }
37584 resultobj = SWIG_Py_Void();
37585 return resultobj;
37586 fail:
37587 return NULL;
37588 }
37589
37590
37591 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37592 PyObject *resultobj = 0;
37593 wxWindow *arg1 = (wxWindow *) 0 ;
37594 bool result;
37595 void *argp1 = 0 ;
37596 int res1 = 0 ;
37597 PyObject *swig_obj[1] ;
37598
37599 if (!args) SWIG_fail;
37600 swig_obj[0] = args;
37601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37602 if (!SWIG_IsOK(res1)) {
37603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37604 }
37605 arg1 = reinterpret_cast< wxWindow * >(argp1);
37606 {
37607 PyThreadState* __tstate = wxPyBeginAllowThreads();
37608 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37609 wxPyEndAllowThreads(__tstate);
37610 if (PyErr_Occurred()) SWIG_fail;
37611 }
37612 {
37613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37614 }
37615 return resultobj;
37616 fail:
37617 return NULL;
37618 }
37619
37620
37621 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37622 PyObject *obj;
37623 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37624 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37625 return SWIG_Py_Void();
37626 }
37627
37628 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37629 return SWIG_Python_InitShadowInstance(args);
37630 }
37631
37632 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37633 PyObject *resultobj = 0;
37634 long arg1 ;
37635 wxWindow *arg2 = (wxWindow *) NULL ;
37636 wxWindow *result = 0 ;
37637 long val1 ;
37638 int ecode1 = 0 ;
37639 void *argp2 = 0 ;
37640 int res2 = 0 ;
37641 PyObject * obj0 = 0 ;
37642 PyObject * obj1 = 0 ;
37643 char * kwnames[] = {
37644 (char *) "id",(char *) "parent", NULL
37645 };
37646
37647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37648 ecode1 = SWIG_AsVal_long(obj0, &val1);
37649 if (!SWIG_IsOK(ecode1)) {
37650 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37651 }
37652 arg1 = static_cast< long >(val1);
37653 if (obj1) {
37654 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37655 if (!SWIG_IsOK(res2)) {
37656 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37657 }
37658 arg2 = reinterpret_cast< wxWindow * >(argp2);
37659 }
37660 {
37661 if (!wxPyCheckForApp()) SWIG_fail;
37662 PyThreadState* __tstate = wxPyBeginAllowThreads();
37663 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37664 wxPyEndAllowThreads(__tstate);
37665 if (PyErr_Occurred()) SWIG_fail;
37666 }
37667 {
37668 resultobj = wxPyMake_wxObject(result, 0);
37669 }
37670 return resultobj;
37671 fail:
37672 return NULL;
37673 }
37674
37675
37676 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37677 PyObject *resultobj = 0;
37678 wxString *arg1 = 0 ;
37679 wxWindow *arg2 = (wxWindow *) NULL ;
37680 wxWindow *result = 0 ;
37681 bool temp1 = false ;
37682 void *argp2 = 0 ;
37683 int res2 = 0 ;
37684 PyObject * obj0 = 0 ;
37685 PyObject * obj1 = 0 ;
37686 char * kwnames[] = {
37687 (char *) "name",(char *) "parent", NULL
37688 };
37689
37690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37691 {
37692 arg1 = wxString_in_helper(obj0);
37693 if (arg1 == NULL) SWIG_fail;
37694 temp1 = true;
37695 }
37696 if (obj1) {
37697 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37698 if (!SWIG_IsOK(res2)) {
37699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37700 }
37701 arg2 = reinterpret_cast< wxWindow * >(argp2);
37702 }
37703 {
37704 if (!wxPyCheckForApp()) SWIG_fail;
37705 PyThreadState* __tstate = wxPyBeginAllowThreads();
37706 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37707 wxPyEndAllowThreads(__tstate);
37708 if (PyErr_Occurred()) SWIG_fail;
37709 }
37710 {
37711 resultobj = wxPyMake_wxObject(result, 0);
37712 }
37713 {
37714 if (temp1)
37715 delete arg1;
37716 }
37717 return resultobj;
37718 fail:
37719 {
37720 if (temp1)
37721 delete arg1;
37722 }
37723 return NULL;
37724 }
37725
37726
37727 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37728 PyObject *resultobj = 0;
37729 wxString *arg1 = 0 ;
37730 wxWindow *arg2 = (wxWindow *) NULL ;
37731 wxWindow *result = 0 ;
37732 bool temp1 = false ;
37733 void *argp2 = 0 ;
37734 int res2 = 0 ;
37735 PyObject * obj0 = 0 ;
37736 PyObject * obj1 = 0 ;
37737 char * kwnames[] = {
37738 (char *) "label",(char *) "parent", NULL
37739 };
37740
37741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37742 {
37743 arg1 = wxString_in_helper(obj0);
37744 if (arg1 == NULL) SWIG_fail;
37745 temp1 = true;
37746 }
37747 if (obj1) {
37748 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37749 if (!SWIG_IsOK(res2)) {
37750 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37751 }
37752 arg2 = reinterpret_cast< wxWindow * >(argp2);
37753 }
37754 {
37755 if (!wxPyCheckForApp()) SWIG_fail;
37756 PyThreadState* __tstate = wxPyBeginAllowThreads();
37757 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37758 wxPyEndAllowThreads(__tstate);
37759 if (PyErr_Occurred()) SWIG_fail;
37760 }
37761 {
37762 resultobj = wxPyMake_wxObject(result, 0);
37763 }
37764 {
37765 if (temp1)
37766 delete arg1;
37767 }
37768 return resultobj;
37769 fail:
37770 {
37771 if (temp1)
37772 delete arg1;
37773 }
37774 return NULL;
37775 }
37776
37777
37778 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37779 PyObject *resultobj = 0;
37780 wxWindow *arg1 = (wxWindow *) 0 ;
37781 unsigned long arg2 ;
37782 wxWindow *result = 0 ;
37783 void *argp1 = 0 ;
37784 int res1 = 0 ;
37785 unsigned long val2 ;
37786 int ecode2 = 0 ;
37787 PyObject * obj0 = 0 ;
37788 PyObject * obj1 = 0 ;
37789 char * kwnames[] = {
37790 (char *) "parent",(char *) "_hWnd", NULL
37791 };
37792
37793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37795 if (!SWIG_IsOK(res1)) {
37796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37797 }
37798 arg1 = reinterpret_cast< wxWindow * >(argp1);
37799 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37800 if (!SWIG_IsOK(ecode2)) {
37801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37802 }
37803 arg2 = static_cast< unsigned long >(val2);
37804 {
37805 PyThreadState* __tstate = wxPyBeginAllowThreads();
37806 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37807 wxPyEndAllowThreads(__tstate);
37808 if (PyErr_Occurred()) SWIG_fail;
37809 }
37810 {
37811 resultobj = wxPyMake_wxObject(result, 0);
37812 }
37813 return resultobj;
37814 fail:
37815 return NULL;
37816 }
37817
37818
37819 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37820 PyObject *resultobj = 0;
37821 PyObject *result = 0 ;
37822
37823 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37824 {
37825 PyThreadState* __tstate = wxPyBeginAllowThreads();
37826 result = (PyObject *)GetTopLevelWindows();
37827 wxPyEndAllowThreads(__tstate);
37828 if (PyErr_Occurred()) SWIG_fail;
37829 }
37830 resultobj = result;
37831 return resultobj;
37832 fail:
37833 return NULL;
37834 }
37835
37836
37837 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37838 PyObject *resultobj = 0;
37839 wxValidator *result = 0 ;
37840
37841 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37842 {
37843 PyThreadState* __tstate = wxPyBeginAllowThreads();
37844 result = (wxValidator *)new wxValidator();
37845 wxPyEndAllowThreads(__tstate);
37846 if (PyErr_Occurred()) SWIG_fail;
37847 }
37848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37849 return resultobj;
37850 fail:
37851 return NULL;
37852 }
37853
37854
37855 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37856 PyObject *resultobj = 0;
37857 wxValidator *arg1 = (wxValidator *) 0 ;
37858 wxValidator *result = 0 ;
37859 void *argp1 = 0 ;
37860 int res1 = 0 ;
37861 PyObject *swig_obj[1] ;
37862
37863 if (!args) SWIG_fail;
37864 swig_obj[0] = args;
37865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37866 if (!SWIG_IsOK(res1)) {
37867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37868 }
37869 arg1 = reinterpret_cast< wxValidator * >(argp1);
37870 {
37871 PyThreadState* __tstate = wxPyBeginAllowThreads();
37872 result = (wxValidator *)(arg1)->Clone();
37873 wxPyEndAllowThreads(__tstate);
37874 if (PyErr_Occurred()) SWIG_fail;
37875 }
37876 {
37877 resultobj = wxPyMake_wxObject(result, 0);
37878 }
37879 return resultobj;
37880 fail:
37881 return NULL;
37882 }
37883
37884
37885 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37886 PyObject *resultobj = 0;
37887 wxValidator *arg1 = (wxValidator *) 0 ;
37888 wxWindow *arg2 = (wxWindow *) 0 ;
37889 bool result;
37890 void *argp1 = 0 ;
37891 int res1 = 0 ;
37892 void *argp2 = 0 ;
37893 int res2 = 0 ;
37894 PyObject * obj0 = 0 ;
37895 PyObject * obj1 = 0 ;
37896 char * kwnames[] = {
37897 (char *) "self",(char *) "parent", NULL
37898 };
37899
37900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37902 if (!SWIG_IsOK(res1)) {
37903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37904 }
37905 arg1 = reinterpret_cast< wxValidator * >(argp1);
37906 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37907 if (!SWIG_IsOK(res2)) {
37908 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37909 }
37910 arg2 = reinterpret_cast< wxWindow * >(argp2);
37911 {
37912 PyThreadState* __tstate = wxPyBeginAllowThreads();
37913 result = (bool)(arg1)->Validate(arg2);
37914 wxPyEndAllowThreads(__tstate);
37915 if (PyErr_Occurred()) SWIG_fail;
37916 }
37917 {
37918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37919 }
37920 return resultobj;
37921 fail:
37922 return NULL;
37923 }
37924
37925
37926 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37927 PyObject *resultobj = 0;
37928 wxValidator *arg1 = (wxValidator *) 0 ;
37929 bool result;
37930 void *argp1 = 0 ;
37931 int res1 = 0 ;
37932 PyObject *swig_obj[1] ;
37933
37934 if (!args) SWIG_fail;
37935 swig_obj[0] = args;
37936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37937 if (!SWIG_IsOK(res1)) {
37938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37939 }
37940 arg1 = reinterpret_cast< wxValidator * >(argp1);
37941 {
37942 PyThreadState* __tstate = wxPyBeginAllowThreads();
37943 result = (bool)(arg1)->TransferToWindow();
37944 wxPyEndAllowThreads(__tstate);
37945 if (PyErr_Occurred()) SWIG_fail;
37946 }
37947 {
37948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37949 }
37950 return resultobj;
37951 fail:
37952 return NULL;
37953 }
37954
37955
37956 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37957 PyObject *resultobj = 0;
37958 wxValidator *arg1 = (wxValidator *) 0 ;
37959 bool result;
37960 void *argp1 = 0 ;
37961 int res1 = 0 ;
37962 PyObject *swig_obj[1] ;
37963
37964 if (!args) SWIG_fail;
37965 swig_obj[0] = args;
37966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37967 if (!SWIG_IsOK(res1)) {
37968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37969 }
37970 arg1 = reinterpret_cast< wxValidator * >(argp1);
37971 {
37972 PyThreadState* __tstate = wxPyBeginAllowThreads();
37973 result = (bool)(arg1)->TransferFromWindow();
37974 wxPyEndAllowThreads(__tstate);
37975 if (PyErr_Occurred()) SWIG_fail;
37976 }
37977 {
37978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37979 }
37980 return resultobj;
37981 fail:
37982 return NULL;
37983 }
37984
37985
37986 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37987 PyObject *resultobj = 0;
37988 wxValidator *arg1 = (wxValidator *) 0 ;
37989 wxWindow *result = 0 ;
37990 void *argp1 = 0 ;
37991 int res1 = 0 ;
37992 PyObject *swig_obj[1] ;
37993
37994 if (!args) SWIG_fail;
37995 swig_obj[0] = args;
37996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37997 if (!SWIG_IsOK(res1)) {
37998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37999 }
38000 arg1 = reinterpret_cast< wxValidator * >(argp1);
38001 {
38002 PyThreadState* __tstate = wxPyBeginAllowThreads();
38003 result = (wxWindow *)(arg1)->GetWindow();
38004 wxPyEndAllowThreads(__tstate);
38005 if (PyErr_Occurred()) SWIG_fail;
38006 }
38007 {
38008 resultobj = wxPyMake_wxObject(result, 0);
38009 }
38010 return resultobj;
38011 fail:
38012 return NULL;
38013 }
38014
38015
38016 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38017 PyObject *resultobj = 0;
38018 wxValidator *arg1 = (wxValidator *) 0 ;
38019 wxWindow *arg2 = (wxWindow *) 0 ;
38020 void *argp1 = 0 ;
38021 int res1 = 0 ;
38022 void *argp2 = 0 ;
38023 int res2 = 0 ;
38024 PyObject * obj0 = 0 ;
38025 PyObject * obj1 = 0 ;
38026 char * kwnames[] = {
38027 (char *) "self",(char *) "window", NULL
38028 };
38029
38030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38032 if (!SWIG_IsOK(res1)) {
38033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38034 }
38035 arg1 = reinterpret_cast< wxValidator * >(argp1);
38036 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38037 if (!SWIG_IsOK(res2)) {
38038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38039 }
38040 arg2 = reinterpret_cast< wxWindow * >(argp2);
38041 {
38042 PyThreadState* __tstate = wxPyBeginAllowThreads();
38043 (arg1)->SetWindow(arg2);
38044 wxPyEndAllowThreads(__tstate);
38045 if (PyErr_Occurred()) SWIG_fail;
38046 }
38047 resultobj = SWIG_Py_Void();
38048 return resultobj;
38049 fail:
38050 return NULL;
38051 }
38052
38053
38054 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38055 PyObject *resultobj = 0;
38056 bool result;
38057
38058 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38059 {
38060 PyThreadState* __tstate = wxPyBeginAllowThreads();
38061 result = (bool)wxValidator::IsSilent();
38062 wxPyEndAllowThreads(__tstate);
38063 if (PyErr_Occurred()) SWIG_fail;
38064 }
38065 {
38066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38067 }
38068 return resultobj;
38069 fail:
38070 return NULL;
38071 }
38072
38073
38074 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38075 PyObject *resultobj = 0;
38076 int arg1 = (int) true ;
38077 int val1 ;
38078 int ecode1 = 0 ;
38079 PyObject * obj0 = 0 ;
38080 char * kwnames[] = {
38081 (char *) "doIt", NULL
38082 };
38083
38084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38085 if (obj0) {
38086 ecode1 = SWIG_AsVal_int(obj0, &val1);
38087 if (!SWIG_IsOK(ecode1)) {
38088 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38089 }
38090 arg1 = static_cast< int >(val1);
38091 }
38092 {
38093 PyThreadState* __tstate = wxPyBeginAllowThreads();
38094 wxValidator::SetBellOnError(arg1);
38095 wxPyEndAllowThreads(__tstate);
38096 if (PyErr_Occurred()) SWIG_fail;
38097 }
38098 resultobj = SWIG_Py_Void();
38099 return resultobj;
38100 fail:
38101 return NULL;
38102 }
38103
38104
38105 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38106 PyObject *obj;
38107 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38108 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38109 return SWIG_Py_Void();
38110 }
38111
38112 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38113 return SWIG_Python_InitShadowInstance(args);
38114 }
38115
38116 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38117 PyObject *resultobj = 0;
38118 wxPyValidator *result = 0 ;
38119
38120 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38121 {
38122 PyThreadState* __tstate = wxPyBeginAllowThreads();
38123 result = (wxPyValidator *)new wxPyValidator();
38124 wxPyEndAllowThreads(__tstate);
38125 if (PyErr_Occurred()) SWIG_fail;
38126 }
38127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38128 return resultobj;
38129 fail:
38130 return NULL;
38131 }
38132
38133
38134 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38135 PyObject *resultobj = 0;
38136 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38137 PyObject *arg2 = (PyObject *) 0 ;
38138 PyObject *arg3 = (PyObject *) 0 ;
38139 int arg4 = (int) true ;
38140 void *argp1 = 0 ;
38141 int res1 = 0 ;
38142 int val4 ;
38143 int ecode4 = 0 ;
38144 PyObject * obj0 = 0 ;
38145 PyObject * obj1 = 0 ;
38146 PyObject * obj2 = 0 ;
38147 PyObject * obj3 = 0 ;
38148 char * kwnames[] = {
38149 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38150 };
38151
38152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38154 if (!SWIG_IsOK(res1)) {
38155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38156 }
38157 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38158 arg2 = obj1;
38159 arg3 = obj2;
38160 if (obj3) {
38161 ecode4 = SWIG_AsVal_int(obj3, &val4);
38162 if (!SWIG_IsOK(ecode4)) {
38163 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38164 }
38165 arg4 = static_cast< int >(val4);
38166 }
38167 {
38168 PyThreadState* __tstate = wxPyBeginAllowThreads();
38169 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38170 wxPyEndAllowThreads(__tstate);
38171 if (PyErr_Occurred()) SWIG_fail;
38172 }
38173 resultobj = SWIG_Py_Void();
38174 return resultobj;
38175 fail:
38176 return NULL;
38177 }
38178
38179
38180 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38181 PyObject *obj;
38182 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38183 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38184 return SWIG_Py_Void();
38185 }
38186
38187 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38188 return SWIG_Python_InitShadowInstance(args);
38189 }
38190
38191 SWIGINTERN int DefaultValidator_set(PyObject *) {
38192 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38193 return 1;
38194 }
38195
38196
38197 SWIGINTERN PyObject *DefaultValidator_get(void) {
38198 PyObject *pyobj = 0;
38199
38200 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38201 return pyobj;
38202 }
38203
38204
38205 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38206 PyObject *resultobj = 0;
38207 wxString const &arg1_defvalue = wxPyEmptyString ;
38208 wxString *arg1 = (wxString *) &arg1_defvalue ;
38209 long arg2 = (long) 0 ;
38210 wxMenu *result = 0 ;
38211 bool temp1 = false ;
38212 long val2 ;
38213 int ecode2 = 0 ;
38214 PyObject * obj0 = 0 ;
38215 PyObject * obj1 = 0 ;
38216 char * kwnames[] = {
38217 (char *) "title",(char *) "style", NULL
38218 };
38219
38220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38221 if (obj0) {
38222 {
38223 arg1 = wxString_in_helper(obj0);
38224 if (arg1 == NULL) SWIG_fail;
38225 temp1 = true;
38226 }
38227 }
38228 if (obj1) {
38229 ecode2 = SWIG_AsVal_long(obj1, &val2);
38230 if (!SWIG_IsOK(ecode2)) {
38231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38232 }
38233 arg2 = static_cast< long >(val2);
38234 }
38235 {
38236 if (!wxPyCheckForApp()) SWIG_fail;
38237 PyThreadState* __tstate = wxPyBeginAllowThreads();
38238 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38239 wxPyEndAllowThreads(__tstate);
38240 if (PyErr_Occurred()) SWIG_fail;
38241 }
38242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38243 {
38244 if (temp1)
38245 delete arg1;
38246 }
38247 return resultobj;
38248 fail:
38249 {
38250 if (temp1)
38251 delete arg1;
38252 }
38253 return NULL;
38254 }
38255
38256
38257 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38258 PyObject *resultobj = 0;
38259 wxMenu *arg1 = (wxMenu *) 0 ;
38260 int arg2 ;
38261 wxString *arg3 = 0 ;
38262 wxString const &arg4_defvalue = wxPyEmptyString ;
38263 wxString *arg4 = (wxString *) &arg4_defvalue ;
38264 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38265 wxMenuItem *result = 0 ;
38266 void *argp1 = 0 ;
38267 int res1 = 0 ;
38268 int val2 ;
38269 int ecode2 = 0 ;
38270 bool temp3 = false ;
38271 bool temp4 = false ;
38272 int val5 ;
38273 int ecode5 = 0 ;
38274 PyObject * obj0 = 0 ;
38275 PyObject * obj1 = 0 ;
38276 PyObject * obj2 = 0 ;
38277 PyObject * obj3 = 0 ;
38278 PyObject * obj4 = 0 ;
38279 char * kwnames[] = {
38280 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38281 };
38282
38283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38285 if (!SWIG_IsOK(res1)) {
38286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38287 }
38288 arg1 = reinterpret_cast< wxMenu * >(argp1);
38289 ecode2 = SWIG_AsVal_int(obj1, &val2);
38290 if (!SWIG_IsOK(ecode2)) {
38291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38292 }
38293 arg2 = static_cast< int >(val2);
38294 {
38295 arg3 = wxString_in_helper(obj2);
38296 if (arg3 == NULL) SWIG_fail;
38297 temp3 = true;
38298 }
38299 if (obj3) {
38300 {
38301 arg4 = wxString_in_helper(obj3);
38302 if (arg4 == NULL) SWIG_fail;
38303 temp4 = true;
38304 }
38305 }
38306 if (obj4) {
38307 ecode5 = SWIG_AsVal_int(obj4, &val5);
38308 if (!SWIG_IsOK(ecode5)) {
38309 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38310 }
38311 arg5 = static_cast< wxItemKind >(val5);
38312 }
38313 {
38314 PyThreadState* __tstate = wxPyBeginAllowThreads();
38315 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38316 wxPyEndAllowThreads(__tstate);
38317 if (PyErr_Occurred()) SWIG_fail;
38318 }
38319 {
38320 resultobj = wxPyMake_wxObject(result, (bool)0);
38321 }
38322 {
38323 if (temp3)
38324 delete arg3;
38325 }
38326 {
38327 if (temp4)
38328 delete arg4;
38329 }
38330 return resultobj;
38331 fail:
38332 {
38333 if (temp3)
38334 delete arg3;
38335 }
38336 {
38337 if (temp4)
38338 delete arg4;
38339 }
38340 return NULL;
38341 }
38342
38343
38344 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38345 PyObject *resultobj = 0;
38346 wxMenu *arg1 = (wxMenu *) 0 ;
38347 wxMenuItem *result = 0 ;
38348 void *argp1 = 0 ;
38349 int res1 = 0 ;
38350 PyObject *swig_obj[1] ;
38351
38352 if (!args) SWIG_fail;
38353 swig_obj[0] = args;
38354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38355 if (!SWIG_IsOK(res1)) {
38356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38357 }
38358 arg1 = reinterpret_cast< wxMenu * >(argp1);
38359 {
38360 PyThreadState* __tstate = wxPyBeginAllowThreads();
38361 result = (wxMenuItem *)(arg1)->AppendSeparator();
38362 wxPyEndAllowThreads(__tstate);
38363 if (PyErr_Occurred()) SWIG_fail;
38364 }
38365 {
38366 resultobj = wxPyMake_wxObject(result, (bool)0);
38367 }
38368 return resultobj;
38369 fail:
38370 return NULL;
38371 }
38372
38373
38374 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38375 PyObject *resultobj = 0;
38376 wxMenu *arg1 = (wxMenu *) 0 ;
38377 int arg2 ;
38378 wxString *arg3 = 0 ;
38379 wxString const &arg4_defvalue = wxPyEmptyString ;
38380 wxString *arg4 = (wxString *) &arg4_defvalue ;
38381 wxMenuItem *result = 0 ;
38382 void *argp1 = 0 ;
38383 int res1 = 0 ;
38384 int val2 ;
38385 int ecode2 = 0 ;
38386 bool temp3 = false ;
38387 bool temp4 = false ;
38388 PyObject * obj0 = 0 ;
38389 PyObject * obj1 = 0 ;
38390 PyObject * obj2 = 0 ;
38391 PyObject * obj3 = 0 ;
38392 char * kwnames[] = {
38393 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38394 };
38395
38396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38398 if (!SWIG_IsOK(res1)) {
38399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38400 }
38401 arg1 = reinterpret_cast< wxMenu * >(argp1);
38402 ecode2 = SWIG_AsVal_int(obj1, &val2);
38403 if (!SWIG_IsOK(ecode2)) {
38404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38405 }
38406 arg2 = static_cast< int >(val2);
38407 {
38408 arg3 = wxString_in_helper(obj2);
38409 if (arg3 == NULL) SWIG_fail;
38410 temp3 = true;
38411 }
38412 if (obj3) {
38413 {
38414 arg4 = wxString_in_helper(obj3);
38415 if (arg4 == NULL) SWIG_fail;
38416 temp4 = true;
38417 }
38418 }
38419 {
38420 PyThreadState* __tstate = wxPyBeginAllowThreads();
38421 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38422 wxPyEndAllowThreads(__tstate);
38423 if (PyErr_Occurred()) SWIG_fail;
38424 }
38425 {
38426 resultobj = wxPyMake_wxObject(result, (bool)0);
38427 }
38428 {
38429 if (temp3)
38430 delete arg3;
38431 }
38432 {
38433 if (temp4)
38434 delete arg4;
38435 }
38436 return resultobj;
38437 fail:
38438 {
38439 if (temp3)
38440 delete arg3;
38441 }
38442 {
38443 if (temp4)
38444 delete arg4;
38445 }
38446 return NULL;
38447 }
38448
38449
38450 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38451 PyObject *resultobj = 0;
38452 wxMenu *arg1 = (wxMenu *) 0 ;
38453 int arg2 ;
38454 wxString *arg3 = 0 ;
38455 wxString const &arg4_defvalue = wxPyEmptyString ;
38456 wxString *arg4 = (wxString *) &arg4_defvalue ;
38457 wxMenuItem *result = 0 ;
38458 void *argp1 = 0 ;
38459 int res1 = 0 ;
38460 int val2 ;
38461 int ecode2 = 0 ;
38462 bool temp3 = false ;
38463 bool temp4 = false ;
38464 PyObject * obj0 = 0 ;
38465 PyObject * obj1 = 0 ;
38466 PyObject * obj2 = 0 ;
38467 PyObject * obj3 = 0 ;
38468 char * kwnames[] = {
38469 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38470 };
38471
38472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38474 if (!SWIG_IsOK(res1)) {
38475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38476 }
38477 arg1 = reinterpret_cast< wxMenu * >(argp1);
38478 ecode2 = SWIG_AsVal_int(obj1, &val2);
38479 if (!SWIG_IsOK(ecode2)) {
38480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38481 }
38482 arg2 = static_cast< int >(val2);
38483 {
38484 arg3 = wxString_in_helper(obj2);
38485 if (arg3 == NULL) SWIG_fail;
38486 temp3 = true;
38487 }
38488 if (obj3) {
38489 {
38490 arg4 = wxString_in_helper(obj3);
38491 if (arg4 == NULL) SWIG_fail;
38492 temp4 = true;
38493 }
38494 }
38495 {
38496 PyThreadState* __tstate = wxPyBeginAllowThreads();
38497 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38498 wxPyEndAllowThreads(__tstate);
38499 if (PyErr_Occurred()) SWIG_fail;
38500 }
38501 {
38502 resultobj = wxPyMake_wxObject(result, (bool)0);
38503 }
38504 {
38505 if (temp3)
38506 delete arg3;
38507 }
38508 {
38509 if (temp4)
38510 delete arg4;
38511 }
38512 return resultobj;
38513 fail:
38514 {
38515 if (temp3)
38516 delete arg3;
38517 }
38518 {
38519 if (temp4)
38520 delete arg4;
38521 }
38522 return NULL;
38523 }
38524
38525
38526 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38527 PyObject *resultobj = 0;
38528 wxMenu *arg1 = (wxMenu *) 0 ;
38529 int arg2 ;
38530 wxString *arg3 = 0 ;
38531 wxMenu *arg4 = (wxMenu *) 0 ;
38532 wxString const &arg5_defvalue = wxPyEmptyString ;
38533 wxString *arg5 = (wxString *) &arg5_defvalue ;
38534 wxMenuItem *result = 0 ;
38535 void *argp1 = 0 ;
38536 int res1 = 0 ;
38537 int val2 ;
38538 int ecode2 = 0 ;
38539 bool temp3 = false ;
38540 void *argp4 = 0 ;
38541 int res4 = 0 ;
38542 bool temp5 = false ;
38543 PyObject * obj0 = 0 ;
38544 PyObject * obj1 = 0 ;
38545 PyObject * obj2 = 0 ;
38546 PyObject * obj3 = 0 ;
38547 PyObject * obj4 = 0 ;
38548 char * kwnames[] = {
38549 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38550 };
38551
38552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38554 if (!SWIG_IsOK(res1)) {
38555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38556 }
38557 arg1 = reinterpret_cast< wxMenu * >(argp1);
38558 ecode2 = SWIG_AsVal_int(obj1, &val2);
38559 if (!SWIG_IsOK(ecode2)) {
38560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38561 }
38562 arg2 = static_cast< int >(val2);
38563 {
38564 arg3 = wxString_in_helper(obj2);
38565 if (arg3 == NULL) SWIG_fail;
38566 temp3 = true;
38567 }
38568 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38569 if (!SWIG_IsOK(res4)) {
38570 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38571 }
38572 arg4 = reinterpret_cast< wxMenu * >(argp4);
38573 if (obj4) {
38574 {
38575 arg5 = wxString_in_helper(obj4);
38576 if (arg5 == NULL) SWIG_fail;
38577 temp5 = true;
38578 }
38579 }
38580 {
38581 PyThreadState* __tstate = wxPyBeginAllowThreads();
38582 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38583 wxPyEndAllowThreads(__tstate);
38584 if (PyErr_Occurred()) SWIG_fail;
38585 }
38586 {
38587 resultobj = wxPyMake_wxObject(result, (bool)0);
38588 }
38589 {
38590 if (temp3)
38591 delete arg3;
38592 }
38593 {
38594 if (temp5)
38595 delete arg5;
38596 }
38597 return resultobj;
38598 fail:
38599 {
38600 if (temp3)
38601 delete arg3;
38602 }
38603 {
38604 if (temp5)
38605 delete arg5;
38606 }
38607 return NULL;
38608 }
38609
38610
38611 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38612 PyObject *resultobj = 0;
38613 wxMenu *arg1 = (wxMenu *) 0 ;
38614 wxMenu *arg2 = (wxMenu *) 0 ;
38615 wxString *arg3 = 0 ;
38616 wxString const &arg4_defvalue = wxPyEmptyString ;
38617 wxString *arg4 = (wxString *) &arg4_defvalue ;
38618 wxMenuItem *result = 0 ;
38619 void *argp1 = 0 ;
38620 int res1 = 0 ;
38621 void *argp2 = 0 ;
38622 int res2 = 0 ;
38623 bool temp3 = false ;
38624 bool temp4 = false ;
38625 PyObject * obj0 = 0 ;
38626 PyObject * obj1 = 0 ;
38627 PyObject * obj2 = 0 ;
38628 PyObject * obj3 = 0 ;
38629 char * kwnames[] = {
38630 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38631 };
38632
38633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38635 if (!SWIG_IsOK(res1)) {
38636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38637 }
38638 arg1 = reinterpret_cast< wxMenu * >(argp1);
38639 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38640 if (!SWIG_IsOK(res2)) {
38641 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38642 }
38643 arg2 = reinterpret_cast< wxMenu * >(argp2);
38644 {
38645 arg3 = wxString_in_helper(obj2);
38646 if (arg3 == NULL) SWIG_fail;
38647 temp3 = true;
38648 }
38649 if (obj3) {
38650 {
38651 arg4 = wxString_in_helper(obj3);
38652 if (arg4 == NULL) SWIG_fail;
38653 temp4 = true;
38654 }
38655 }
38656 {
38657 PyThreadState* __tstate = wxPyBeginAllowThreads();
38658 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38659 wxPyEndAllowThreads(__tstate);
38660 if (PyErr_Occurred()) SWIG_fail;
38661 }
38662 {
38663 resultobj = wxPyMake_wxObject(result, (bool)0);
38664 }
38665 {
38666 if (temp3)
38667 delete arg3;
38668 }
38669 {
38670 if (temp4)
38671 delete arg4;
38672 }
38673 return resultobj;
38674 fail:
38675 {
38676 if (temp3)
38677 delete arg3;
38678 }
38679 {
38680 if (temp4)
38681 delete arg4;
38682 }
38683 return NULL;
38684 }
38685
38686
38687 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38688 PyObject *resultobj = 0;
38689 wxMenu *arg1 = (wxMenu *) 0 ;
38690 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38691 wxMenuItem *result = 0 ;
38692 void *argp1 = 0 ;
38693 int res1 = 0 ;
38694 int res2 = 0 ;
38695 PyObject * obj0 = 0 ;
38696 PyObject * obj1 = 0 ;
38697 char * kwnames[] = {
38698 (char *) "self",(char *) "item", NULL
38699 };
38700
38701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38703 if (!SWIG_IsOK(res1)) {
38704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38705 }
38706 arg1 = reinterpret_cast< wxMenu * >(argp1);
38707 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38708 if (!SWIG_IsOK(res2)) {
38709 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38710 }
38711 {
38712 PyThreadState* __tstate = wxPyBeginAllowThreads();
38713 result = (wxMenuItem *)(arg1)->Append(arg2);
38714 wxPyEndAllowThreads(__tstate);
38715 if (PyErr_Occurred()) SWIG_fail;
38716 }
38717 {
38718 resultobj = wxPyMake_wxObject(result, (bool)0);
38719 }
38720 return resultobj;
38721 fail:
38722 return NULL;
38723 }
38724
38725
38726 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38727 PyObject *resultobj = 0;
38728 wxMenu *arg1 = (wxMenu *) 0 ;
38729 size_t arg2 ;
38730 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38731 wxMenuItem *result = 0 ;
38732 void *argp1 = 0 ;
38733 int res1 = 0 ;
38734 size_t val2 ;
38735 int ecode2 = 0 ;
38736 int res3 = 0 ;
38737 PyObject * obj0 = 0 ;
38738 PyObject * obj1 = 0 ;
38739 PyObject * obj2 = 0 ;
38740 char * kwnames[] = {
38741 (char *) "self",(char *) "pos",(char *) "item", NULL
38742 };
38743
38744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38746 if (!SWIG_IsOK(res1)) {
38747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38748 }
38749 arg1 = reinterpret_cast< wxMenu * >(argp1);
38750 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38751 if (!SWIG_IsOK(ecode2)) {
38752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38753 }
38754 arg2 = static_cast< size_t >(val2);
38755 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38756 if (!SWIG_IsOK(res3)) {
38757 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38758 }
38759 {
38760 PyThreadState* __tstate = wxPyBeginAllowThreads();
38761 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38762 wxPyEndAllowThreads(__tstate);
38763 if (PyErr_Occurred()) SWIG_fail;
38764 }
38765 {
38766 resultobj = wxPyMake_wxObject(result, (bool)0);
38767 }
38768 return resultobj;
38769 fail:
38770 return NULL;
38771 }
38772
38773
38774 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38775 PyObject *resultobj = 0;
38776 wxMenu *arg1 = (wxMenu *) 0 ;
38777 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38778 wxMenuItem *result = 0 ;
38779 void *argp1 = 0 ;
38780 int res1 = 0 ;
38781 int res2 = 0 ;
38782 PyObject * obj0 = 0 ;
38783 PyObject * obj1 = 0 ;
38784 char * kwnames[] = {
38785 (char *) "self",(char *) "item", NULL
38786 };
38787
38788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38790 if (!SWIG_IsOK(res1)) {
38791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38792 }
38793 arg1 = reinterpret_cast< wxMenu * >(argp1);
38794 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38795 if (!SWIG_IsOK(res2)) {
38796 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38797 }
38798 {
38799 PyThreadState* __tstate = wxPyBeginAllowThreads();
38800 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38801 wxPyEndAllowThreads(__tstate);
38802 if (PyErr_Occurred()) SWIG_fail;
38803 }
38804 {
38805 resultobj = wxPyMake_wxObject(result, (bool)0);
38806 }
38807 return resultobj;
38808 fail:
38809 return NULL;
38810 }
38811
38812
38813 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38814 PyObject *resultobj = 0;
38815 wxMenu *arg1 = (wxMenu *) 0 ;
38816 void *argp1 = 0 ;
38817 int res1 = 0 ;
38818 PyObject *swig_obj[1] ;
38819
38820 if (!args) SWIG_fail;
38821 swig_obj[0] = args;
38822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38823 if (!SWIG_IsOK(res1)) {
38824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38825 }
38826 arg1 = reinterpret_cast< wxMenu * >(argp1);
38827 {
38828 PyThreadState* __tstate = wxPyBeginAllowThreads();
38829 (arg1)->Break();
38830 wxPyEndAllowThreads(__tstate);
38831 if (PyErr_Occurred()) SWIG_fail;
38832 }
38833 resultobj = SWIG_Py_Void();
38834 return resultobj;
38835 fail:
38836 return NULL;
38837 }
38838
38839
38840 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38841 PyObject *resultobj = 0;
38842 wxMenu *arg1 = (wxMenu *) 0 ;
38843 size_t arg2 ;
38844 int arg3 ;
38845 wxString *arg4 = 0 ;
38846 wxString const &arg5_defvalue = wxPyEmptyString ;
38847 wxString *arg5 = (wxString *) &arg5_defvalue ;
38848 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38849 wxMenuItem *result = 0 ;
38850 void *argp1 = 0 ;
38851 int res1 = 0 ;
38852 size_t val2 ;
38853 int ecode2 = 0 ;
38854 int val3 ;
38855 int ecode3 = 0 ;
38856 bool temp4 = false ;
38857 bool temp5 = false ;
38858 int val6 ;
38859 int ecode6 = 0 ;
38860 PyObject * obj0 = 0 ;
38861 PyObject * obj1 = 0 ;
38862 PyObject * obj2 = 0 ;
38863 PyObject * obj3 = 0 ;
38864 PyObject * obj4 = 0 ;
38865 PyObject * obj5 = 0 ;
38866 char * kwnames[] = {
38867 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38868 };
38869
38870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38872 if (!SWIG_IsOK(res1)) {
38873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38874 }
38875 arg1 = reinterpret_cast< wxMenu * >(argp1);
38876 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38877 if (!SWIG_IsOK(ecode2)) {
38878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38879 }
38880 arg2 = static_cast< size_t >(val2);
38881 ecode3 = SWIG_AsVal_int(obj2, &val3);
38882 if (!SWIG_IsOK(ecode3)) {
38883 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38884 }
38885 arg3 = static_cast< int >(val3);
38886 {
38887 arg4 = wxString_in_helper(obj3);
38888 if (arg4 == NULL) SWIG_fail;
38889 temp4 = true;
38890 }
38891 if (obj4) {
38892 {
38893 arg5 = wxString_in_helper(obj4);
38894 if (arg5 == NULL) SWIG_fail;
38895 temp5 = true;
38896 }
38897 }
38898 if (obj5) {
38899 ecode6 = SWIG_AsVal_int(obj5, &val6);
38900 if (!SWIG_IsOK(ecode6)) {
38901 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38902 }
38903 arg6 = static_cast< wxItemKind >(val6);
38904 }
38905 {
38906 PyThreadState* __tstate = wxPyBeginAllowThreads();
38907 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38908 wxPyEndAllowThreads(__tstate);
38909 if (PyErr_Occurred()) SWIG_fail;
38910 }
38911 {
38912 resultobj = wxPyMake_wxObject(result, (bool)0);
38913 }
38914 {
38915 if (temp4)
38916 delete arg4;
38917 }
38918 {
38919 if (temp5)
38920 delete arg5;
38921 }
38922 return resultobj;
38923 fail:
38924 {
38925 if (temp4)
38926 delete arg4;
38927 }
38928 {
38929 if (temp5)
38930 delete arg5;
38931 }
38932 return NULL;
38933 }
38934
38935
38936 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38937 PyObject *resultobj = 0;
38938 wxMenu *arg1 = (wxMenu *) 0 ;
38939 size_t arg2 ;
38940 wxMenuItem *result = 0 ;
38941 void *argp1 = 0 ;
38942 int res1 = 0 ;
38943 size_t val2 ;
38944 int ecode2 = 0 ;
38945 PyObject * obj0 = 0 ;
38946 PyObject * obj1 = 0 ;
38947 char * kwnames[] = {
38948 (char *) "self",(char *) "pos", NULL
38949 };
38950
38951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38953 if (!SWIG_IsOK(res1)) {
38954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38955 }
38956 arg1 = reinterpret_cast< wxMenu * >(argp1);
38957 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38958 if (!SWIG_IsOK(ecode2)) {
38959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38960 }
38961 arg2 = static_cast< size_t >(val2);
38962 {
38963 PyThreadState* __tstate = wxPyBeginAllowThreads();
38964 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38965 wxPyEndAllowThreads(__tstate);
38966 if (PyErr_Occurred()) SWIG_fail;
38967 }
38968 {
38969 resultobj = wxPyMake_wxObject(result, (bool)0);
38970 }
38971 return resultobj;
38972 fail:
38973 return NULL;
38974 }
38975
38976
38977 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38978 PyObject *resultobj = 0;
38979 wxMenu *arg1 = (wxMenu *) 0 ;
38980 size_t arg2 ;
38981 int arg3 ;
38982 wxString *arg4 = 0 ;
38983 wxString const &arg5_defvalue = wxPyEmptyString ;
38984 wxString *arg5 = (wxString *) &arg5_defvalue ;
38985 wxMenuItem *result = 0 ;
38986 void *argp1 = 0 ;
38987 int res1 = 0 ;
38988 size_t val2 ;
38989 int ecode2 = 0 ;
38990 int val3 ;
38991 int ecode3 = 0 ;
38992 bool temp4 = false ;
38993 bool temp5 = false ;
38994 PyObject * obj0 = 0 ;
38995 PyObject * obj1 = 0 ;
38996 PyObject * obj2 = 0 ;
38997 PyObject * obj3 = 0 ;
38998 PyObject * obj4 = 0 ;
38999 char * kwnames[] = {
39000 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39001 };
39002
39003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39005 if (!SWIG_IsOK(res1)) {
39006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39007 }
39008 arg1 = reinterpret_cast< wxMenu * >(argp1);
39009 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39010 if (!SWIG_IsOK(ecode2)) {
39011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39012 }
39013 arg2 = static_cast< size_t >(val2);
39014 ecode3 = SWIG_AsVal_int(obj2, &val3);
39015 if (!SWIG_IsOK(ecode3)) {
39016 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39017 }
39018 arg3 = static_cast< int >(val3);
39019 {
39020 arg4 = wxString_in_helper(obj3);
39021 if (arg4 == NULL) SWIG_fail;
39022 temp4 = true;
39023 }
39024 if (obj4) {
39025 {
39026 arg5 = wxString_in_helper(obj4);
39027 if (arg5 == NULL) SWIG_fail;
39028 temp5 = true;
39029 }
39030 }
39031 {
39032 PyThreadState* __tstate = wxPyBeginAllowThreads();
39033 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39034 wxPyEndAllowThreads(__tstate);
39035 if (PyErr_Occurred()) SWIG_fail;
39036 }
39037 {
39038 resultobj = wxPyMake_wxObject(result, (bool)0);
39039 }
39040 {
39041 if (temp4)
39042 delete arg4;
39043 }
39044 {
39045 if (temp5)
39046 delete arg5;
39047 }
39048 return resultobj;
39049 fail:
39050 {
39051 if (temp4)
39052 delete arg4;
39053 }
39054 {
39055 if (temp5)
39056 delete arg5;
39057 }
39058 return NULL;
39059 }
39060
39061
39062 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39063 PyObject *resultobj = 0;
39064 wxMenu *arg1 = (wxMenu *) 0 ;
39065 size_t arg2 ;
39066 int arg3 ;
39067 wxString *arg4 = 0 ;
39068 wxString const &arg5_defvalue = wxPyEmptyString ;
39069 wxString *arg5 = (wxString *) &arg5_defvalue ;
39070 wxMenuItem *result = 0 ;
39071 void *argp1 = 0 ;
39072 int res1 = 0 ;
39073 size_t val2 ;
39074 int ecode2 = 0 ;
39075 int val3 ;
39076 int ecode3 = 0 ;
39077 bool temp4 = false ;
39078 bool temp5 = false ;
39079 PyObject * obj0 = 0 ;
39080 PyObject * obj1 = 0 ;
39081 PyObject * obj2 = 0 ;
39082 PyObject * obj3 = 0 ;
39083 PyObject * obj4 = 0 ;
39084 char * kwnames[] = {
39085 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39086 };
39087
39088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39090 if (!SWIG_IsOK(res1)) {
39091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39092 }
39093 arg1 = reinterpret_cast< wxMenu * >(argp1);
39094 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39095 if (!SWIG_IsOK(ecode2)) {
39096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39097 }
39098 arg2 = static_cast< size_t >(val2);
39099 ecode3 = SWIG_AsVal_int(obj2, &val3);
39100 if (!SWIG_IsOK(ecode3)) {
39101 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39102 }
39103 arg3 = static_cast< int >(val3);
39104 {
39105 arg4 = wxString_in_helper(obj3);
39106 if (arg4 == NULL) SWIG_fail;
39107 temp4 = true;
39108 }
39109 if (obj4) {
39110 {
39111 arg5 = wxString_in_helper(obj4);
39112 if (arg5 == NULL) SWIG_fail;
39113 temp5 = true;
39114 }
39115 }
39116 {
39117 PyThreadState* __tstate = wxPyBeginAllowThreads();
39118 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39119 wxPyEndAllowThreads(__tstate);
39120 if (PyErr_Occurred()) SWIG_fail;
39121 }
39122 {
39123 resultobj = wxPyMake_wxObject(result, (bool)0);
39124 }
39125 {
39126 if (temp4)
39127 delete arg4;
39128 }
39129 {
39130 if (temp5)
39131 delete arg5;
39132 }
39133 return resultobj;
39134 fail:
39135 {
39136 if (temp4)
39137 delete arg4;
39138 }
39139 {
39140 if (temp5)
39141 delete arg5;
39142 }
39143 return NULL;
39144 }
39145
39146
39147 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39148 PyObject *resultobj = 0;
39149 wxMenu *arg1 = (wxMenu *) 0 ;
39150 size_t arg2 ;
39151 int arg3 ;
39152 wxString *arg4 = 0 ;
39153 wxMenu *arg5 = (wxMenu *) 0 ;
39154 wxString const &arg6_defvalue = wxPyEmptyString ;
39155 wxString *arg6 = (wxString *) &arg6_defvalue ;
39156 wxMenuItem *result = 0 ;
39157 void *argp1 = 0 ;
39158 int res1 = 0 ;
39159 size_t val2 ;
39160 int ecode2 = 0 ;
39161 int val3 ;
39162 int ecode3 = 0 ;
39163 bool temp4 = false ;
39164 void *argp5 = 0 ;
39165 int res5 = 0 ;
39166 bool temp6 = false ;
39167 PyObject * obj0 = 0 ;
39168 PyObject * obj1 = 0 ;
39169 PyObject * obj2 = 0 ;
39170 PyObject * obj3 = 0 ;
39171 PyObject * obj4 = 0 ;
39172 PyObject * obj5 = 0 ;
39173 char * kwnames[] = {
39174 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39175 };
39176
39177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39179 if (!SWIG_IsOK(res1)) {
39180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39181 }
39182 arg1 = reinterpret_cast< wxMenu * >(argp1);
39183 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39184 if (!SWIG_IsOK(ecode2)) {
39185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39186 }
39187 arg2 = static_cast< size_t >(val2);
39188 ecode3 = SWIG_AsVal_int(obj2, &val3);
39189 if (!SWIG_IsOK(ecode3)) {
39190 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39191 }
39192 arg3 = static_cast< int >(val3);
39193 {
39194 arg4 = wxString_in_helper(obj3);
39195 if (arg4 == NULL) SWIG_fail;
39196 temp4 = true;
39197 }
39198 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39199 if (!SWIG_IsOK(res5)) {
39200 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39201 }
39202 arg5 = reinterpret_cast< wxMenu * >(argp5);
39203 if (obj5) {
39204 {
39205 arg6 = wxString_in_helper(obj5);
39206 if (arg6 == NULL) SWIG_fail;
39207 temp6 = true;
39208 }
39209 }
39210 {
39211 PyThreadState* __tstate = wxPyBeginAllowThreads();
39212 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39213 wxPyEndAllowThreads(__tstate);
39214 if (PyErr_Occurred()) SWIG_fail;
39215 }
39216 {
39217 resultobj = wxPyMake_wxObject(result, (bool)0);
39218 }
39219 {
39220 if (temp4)
39221 delete arg4;
39222 }
39223 {
39224 if (temp6)
39225 delete arg6;
39226 }
39227 return resultobj;
39228 fail:
39229 {
39230 if (temp4)
39231 delete arg4;
39232 }
39233 {
39234 if (temp6)
39235 delete arg6;
39236 }
39237 return NULL;
39238 }
39239
39240
39241 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39242 PyObject *resultobj = 0;
39243 wxMenu *arg1 = (wxMenu *) 0 ;
39244 int arg2 ;
39245 wxString *arg3 = 0 ;
39246 wxString const &arg4_defvalue = wxPyEmptyString ;
39247 wxString *arg4 = (wxString *) &arg4_defvalue ;
39248 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39249 wxMenuItem *result = 0 ;
39250 void *argp1 = 0 ;
39251 int res1 = 0 ;
39252 int val2 ;
39253 int ecode2 = 0 ;
39254 bool temp3 = false ;
39255 bool temp4 = false ;
39256 int val5 ;
39257 int ecode5 = 0 ;
39258 PyObject * obj0 = 0 ;
39259 PyObject * obj1 = 0 ;
39260 PyObject * obj2 = 0 ;
39261 PyObject * obj3 = 0 ;
39262 PyObject * obj4 = 0 ;
39263 char * kwnames[] = {
39264 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39265 };
39266
39267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39269 if (!SWIG_IsOK(res1)) {
39270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39271 }
39272 arg1 = reinterpret_cast< wxMenu * >(argp1);
39273 ecode2 = SWIG_AsVal_int(obj1, &val2);
39274 if (!SWIG_IsOK(ecode2)) {
39275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39276 }
39277 arg2 = static_cast< int >(val2);
39278 {
39279 arg3 = wxString_in_helper(obj2);
39280 if (arg3 == NULL) SWIG_fail;
39281 temp3 = true;
39282 }
39283 if (obj3) {
39284 {
39285 arg4 = wxString_in_helper(obj3);
39286 if (arg4 == NULL) SWIG_fail;
39287 temp4 = true;
39288 }
39289 }
39290 if (obj4) {
39291 ecode5 = SWIG_AsVal_int(obj4, &val5);
39292 if (!SWIG_IsOK(ecode5)) {
39293 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39294 }
39295 arg5 = static_cast< wxItemKind >(val5);
39296 }
39297 {
39298 PyThreadState* __tstate = wxPyBeginAllowThreads();
39299 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39300 wxPyEndAllowThreads(__tstate);
39301 if (PyErr_Occurred()) SWIG_fail;
39302 }
39303 {
39304 resultobj = wxPyMake_wxObject(result, (bool)0);
39305 }
39306 {
39307 if (temp3)
39308 delete arg3;
39309 }
39310 {
39311 if (temp4)
39312 delete arg4;
39313 }
39314 return resultobj;
39315 fail:
39316 {
39317 if (temp3)
39318 delete arg3;
39319 }
39320 {
39321 if (temp4)
39322 delete arg4;
39323 }
39324 return NULL;
39325 }
39326
39327
39328 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39329 PyObject *resultobj = 0;
39330 wxMenu *arg1 = (wxMenu *) 0 ;
39331 wxMenuItem *result = 0 ;
39332 void *argp1 = 0 ;
39333 int res1 = 0 ;
39334 PyObject *swig_obj[1] ;
39335
39336 if (!args) SWIG_fail;
39337 swig_obj[0] = args;
39338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39339 if (!SWIG_IsOK(res1)) {
39340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39341 }
39342 arg1 = reinterpret_cast< wxMenu * >(argp1);
39343 {
39344 PyThreadState* __tstate = wxPyBeginAllowThreads();
39345 result = (wxMenuItem *)(arg1)->PrependSeparator();
39346 wxPyEndAllowThreads(__tstate);
39347 if (PyErr_Occurred()) SWIG_fail;
39348 }
39349 {
39350 resultobj = wxPyMake_wxObject(result, (bool)0);
39351 }
39352 return resultobj;
39353 fail:
39354 return NULL;
39355 }
39356
39357
39358 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39359 PyObject *resultobj = 0;
39360 wxMenu *arg1 = (wxMenu *) 0 ;
39361 int arg2 ;
39362 wxString *arg3 = 0 ;
39363 wxString const &arg4_defvalue = wxPyEmptyString ;
39364 wxString *arg4 = (wxString *) &arg4_defvalue ;
39365 wxMenuItem *result = 0 ;
39366 void *argp1 = 0 ;
39367 int res1 = 0 ;
39368 int val2 ;
39369 int ecode2 = 0 ;
39370 bool temp3 = false ;
39371 bool temp4 = false ;
39372 PyObject * obj0 = 0 ;
39373 PyObject * obj1 = 0 ;
39374 PyObject * obj2 = 0 ;
39375 PyObject * obj3 = 0 ;
39376 char * kwnames[] = {
39377 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39378 };
39379
39380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39382 if (!SWIG_IsOK(res1)) {
39383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39384 }
39385 arg1 = reinterpret_cast< wxMenu * >(argp1);
39386 ecode2 = SWIG_AsVal_int(obj1, &val2);
39387 if (!SWIG_IsOK(ecode2)) {
39388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39389 }
39390 arg2 = static_cast< int >(val2);
39391 {
39392 arg3 = wxString_in_helper(obj2);
39393 if (arg3 == NULL) SWIG_fail;
39394 temp3 = true;
39395 }
39396 if (obj3) {
39397 {
39398 arg4 = wxString_in_helper(obj3);
39399 if (arg4 == NULL) SWIG_fail;
39400 temp4 = true;
39401 }
39402 }
39403 {
39404 PyThreadState* __tstate = wxPyBeginAllowThreads();
39405 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39406 wxPyEndAllowThreads(__tstate);
39407 if (PyErr_Occurred()) SWIG_fail;
39408 }
39409 {
39410 resultobj = wxPyMake_wxObject(result, (bool)0);
39411 }
39412 {
39413 if (temp3)
39414 delete arg3;
39415 }
39416 {
39417 if (temp4)
39418 delete arg4;
39419 }
39420 return resultobj;
39421 fail:
39422 {
39423 if (temp3)
39424 delete arg3;
39425 }
39426 {
39427 if (temp4)
39428 delete arg4;
39429 }
39430 return NULL;
39431 }
39432
39433
39434 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39435 PyObject *resultobj = 0;
39436 wxMenu *arg1 = (wxMenu *) 0 ;
39437 int arg2 ;
39438 wxString *arg3 = 0 ;
39439 wxString const &arg4_defvalue = wxPyEmptyString ;
39440 wxString *arg4 = (wxString *) &arg4_defvalue ;
39441 wxMenuItem *result = 0 ;
39442 void *argp1 = 0 ;
39443 int res1 = 0 ;
39444 int val2 ;
39445 int ecode2 = 0 ;
39446 bool temp3 = false ;
39447 bool temp4 = false ;
39448 PyObject * obj0 = 0 ;
39449 PyObject * obj1 = 0 ;
39450 PyObject * obj2 = 0 ;
39451 PyObject * obj3 = 0 ;
39452 char * kwnames[] = {
39453 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39454 };
39455
39456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39458 if (!SWIG_IsOK(res1)) {
39459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39460 }
39461 arg1 = reinterpret_cast< wxMenu * >(argp1);
39462 ecode2 = SWIG_AsVal_int(obj1, &val2);
39463 if (!SWIG_IsOK(ecode2)) {
39464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39465 }
39466 arg2 = static_cast< int >(val2);
39467 {
39468 arg3 = wxString_in_helper(obj2);
39469 if (arg3 == NULL) SWIG_fail;
39470 temp3 = true;
39471 }
39472 if (obj3) {
39473 {
39474 arg4 = wxString_in_helper(obj3);
39475 if (arg4 == NULL) SWIG_fail;
39476 temp4 = true;
39477 }
39478 }
39479 {
39480 PyThreadState* __tstate = wxPyBeginAllowThreads();
39481 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39482 wxPyEndAllowThreads(__tstate);
39483 if (PyErr_Occurred()) SWIG_fail;
39484 }
39485 {
39486 resultobj = wxPyMake_wxObject(result, (bool)0);
39487 }
39488 {
39489 if (temp3)
39490 delete arg3;
39491 }
39492 {
39493 if (temp4)
39494 delete arg4;
39495 }
39496 return resultobj;
39497 fail:
39498 {
39499 if (temp3)
39500 delete arg3;
39501 }
39502 {
39503 if (temp4)
39504 delete arg4;
39505 }
39506 return NULL;
39507 }
39508
39509
39510 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39511 PyObject *resultobj = 0;
39512 wxMenu *arg1 = (wxMenu *) 0 ;
39513 int arg2 ;
39514 wxString *arg3 = 0 ;
39515 wxMenu *arg4 = (wxMenu *) 0 ;
39516 wxString const &arg5_defvalue = wxPyEmptyString ;
39517 wxString *arg5 = (wxString *) &arg5_defvalue ;
39518 wxMenuItem *result = 0 ;
39519 void *argp1 = 0 ;
39520 int res1 = 0 ;
39521 int val2 ;
39522 int ecode2 = 0 ;
39523 bool temp3 = false ;
39524 void *argp4 = 0 ;
39525 int res4 = 0 ;
39526 bool temp5 = false ;
39527 PyObject * obj0 = 0 ;
39528 PyObject * obj1 = 0 ;
39529 PyObject * obj2 = 0 ;
39530 PyObject * obj3 = 0 ;
39531 PyObject * obj4 = 0 ;
39532 char * kwnames[] = {
39533 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39534 };
39535
39536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39538 if (!SWIG_IsOK(res1)) {
39539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39540 }
39541 arg1 = reinterpret_cast< wxMenu * >(argp1);
39542 ecode2 = SWIG_AsVal_int(obj1, &val2);
39543 if (!SWIG_IsOK(ecode2)) {
39544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39545 }
39546 arg2 = static_cast< int >(val2);
39547 {
39548 arg3 = wxString_in_helper(obj2);
39549 if (arg3 == NULL) SWIG_fail;
39550 temp3 = true;
39551 }
39552 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39553 if (!SWIG_IsOK(res4)) {
39554 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39555 }
39556 arg4 = reinterpret_cast< wxMenu * >(argp4);
39557 if (obj4) {
39558 {
39559 arg5 = wxString_in_helper(obj4);
39560 if (arg5 == NULL) SWIG_fail;
39561 temp5 = true;
39562 }
39563 }
39564 {
39565 PyThreadState* __tstate = wxPyBeginAllowThreads();
39566 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39567 wxPyEndAllowThreads(__tstate);
39568 if (PyErr_Occurred()) SWIG_fail;
39569 }
39570 {
39571 resultobj = wxPyMake_wxObject(result, (bool)0);
39572 }
39573 {
39574 if (temp3)
39575 delete arg3;
39576 }
39577 {
39578 if (temp5)
39579 delete arg5;
39580 }
39581 return resultobj;
39582 fail:
39583 {
39584 if (temp3)
39585 delete arg3;
39586 }
39587 {
39588 if (temp5)
39589 delete arg5;
39590 }
39591 return NULL;
39592 }
39593
39594
39595 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39596 PyObject *resultobj = 0;
39597 wxMenu *arg1 = (wxMenu *) 0 ;
39598 int arg2 ;
39599 wxMenuItem *result = 0 ;
39600 void *argp1 = 0 ;
39601 int res1 = 0 ;
39602 int val2 ;
39603 int ecode2 = 0 ;
39604 PyObject * obj0 = 0 ;
39605 PyObject * obj1 = 0 ;
39606 char * kwnames[] = {
39607 (char *) "self",(char *) "id", NULL
39608 };
39609
39610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39612 if (!SWIG_IsOK(res1)) {
39613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39614 }
39615 arg1 = reinterpret_cast< wxMenu * >(argp1);
39616 ecode2 = SWIG_AsVal_int(obj1, &val2);
39617 if (!SWIG_IsOK(ecode2)) {
39618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39619 }
39620 arg2 = static_cast< int >(val2);
39621 {
39622 PyThreadState* __tstate = wxPyBeginAllowThreads();
39623 result = (wxMenuItem *)(arg1)->Remove(arg2);
39624 wxPyEndAllowThreads(__tstate);
39625 if (PyErr_Occurred()) SWIG_fail;
39626 }
39627 {
39628 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39629 }
39630 return resultobj;
39631 fail:
39632 return NULL;
39633 }
39634
39635
39636 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39637 PyObject *resultobj = 0;
39638 wxMenu *arg1 = (wxMenu *) 0 ;
39639 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39640 wxMenuItem *result = 0 ;
39641 void *argp1 = 0 ;
39642 int res1 = 0 ;
39643 void *argp2 = 0 ;
39644 int res2 = 0 ;
39645 PyObject * obj0 = 0 ;
39646 PyObject * obj1 = 0 ;
39647 char * kwnames[] = {
39648 (char *) "self",(char *) "item", NULL
39649 };
39650
39651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39653 if (!SWIG_IsOK(res1)) {
39654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39655 }
39656 arg1 = reinterpret_cast< wxMenu * >(argp1);
39657 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39658 if (!SWIG_IsOK(res2)) {
39659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39660 }
39661 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39662 {
39663 PyThreadState* __tstate = wxPyBeginAllowThreads();
39664 result = (wxMenuItem *)(arg1)->Remove(arg2);
39665 wxPyEndAllowThreads(__tstate);
39666 if (PyErr_Occurred()) SWIG_fail;
39667 }
39668 {
39669 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39670 }
39671 return resultobj;
39672 fail:
39673 return NULL;
39674 }
39675
39676
39677 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39678 PyObject *resultobj = 0;
39679 wxMenu *arg1 = (wxMenu *) 0 ;
39680 int arg2 ;
39681 bool result;
39682 void *argp1 = 0 ;
39683 int res1 = 0 ;
39684 int val2 ;
39685 int ecode2 = 0 ;
39686 PyObject * obj0 = 0 ;
39687 PyObject * obj1 = 0 ;
39688 char * kwnames[] = {
39689 (char *) "self",(char *) "id", NULL
39690 };
39691
39692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39694 if (!SWIG_IsOK(res1)) {
39695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39696 }
39697 arg1 = reinterpret_cast< wxMenu * >(argp1);
39698 ecode2 = SWIG_AsVal_int(obj1, &val2);
39699 if (!SWIG_IsOK(ecode2)) {
39700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39701 }
39702 arg2 = static_cast< int >(val2);
39703 {
39704 PyThreadState* __tstate = wxPyBeginAllowThreads();
39705 result = (bool)(arg1)->Delete(arg2);
39706 wxPyEndAllowThreads(__tstate);
39707 if (PyErr_Occurred()) SWIG_fail;
39708 }
39709 {
39710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39711 }
39712 return resultobj;
39713 fail:
39714 return NULL;
39715 }
39716
39717
39718 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39719 PyObject *resultobj = 0;
39720 wxMenu *arg1 = (wxMenu *) 0 ;
39721 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39722 bool result;
39723 void *argp1 = 0 ;
39724 int res1 = 0 ;
39725 void *argp2 = 0 ;
39726 int res2 = 0 ;
39727 PyObject * obj0 = 0 ;
39728 PyObject * obj1 = 0 ;
39729 char * kwnames[] = {
39730 (char *) "self",(char *) "item", NULL
39731 };
39732
39733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39735 if (!SWIG_IsOK(res1)) {
39736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39737 }
39738 arg1 = reinterpret_cast< wxMenu * >(argp1);
39739 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39740 if (!SWIG_IsOK(res2)) {
39741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39742 }
39743 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39744 {
39745 PyThreadState* __tstate = wxPyBeginAllowThreads();
39746 result = (bool)(arg1)->Delete(arg2);
39747 wxPyEndAllowThreads(__tstate);
39748 if (PyErr_Occurred()) SWIG_fail;
39749 }
39750 {
39751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39752 }
39753 return resultobj;
39754 fail:
39755 return NULL;
39756 }
39757
39758
39759 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39760 PyObject *resultobj = 0;
39761 wxMenu *arg1 = (wxMenu *) 0 ;
39762 void *argp1 = 0 ;
39763 int res1 = 0 ;
39764 PyObject *swig_obj[1] ;
39765
39766 if (!args) SWIG_fail;
39767 swig_obj[0] = args;
39768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39769 if (!SWIG_IsOK(res1)) {
39770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39771 }
39772 arg1 = reinterpret_cast< wxMenu * >(argp1);
39773 {
39774 PyThreadState* __tstate = wxPyBeginAllowThreads();
39775 wxMenu_Destroy(arg1);
39776 wxPyEndAllowThreads(__tstate);
39777 if (PyErr_Occurred()) SWIG_fail;
39778 }
39779 resultobj = SWIG_Py_Void();
39780 return resultobj;
39781 fail:
39782 return NULL;
39783 }
39784
39785
39786 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39787 PyObject *resultobj = 0;
39788 wxMenu *arg1 = (wxMenu *) 0 ;
39789 int arg2 ;
39790 bool result;
39791 void *argp1 = 0 ;
39792 int res1 = 0 ;
39793 int val2 ;
39794 int ecode2 = 0 ;
39795 PyObject * obj0 = 0 ;
39796 PyObject * obj1 = 0 ;
39797 char * kwnames[] = {
39798 (char *) "self",(char *) "id", NULL
39799 };
39800
39801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39803 if (!SWIG_IsOK(res1)) {
39804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39805 }
39806 arg1 = reinterpret_cast< wxMenu * >(argp1);
39807 ecode2 = SWIG_AsVal_int(obj1, &val2);
39808 if (!SWIG_IsOK(ecode2)) {
39809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39810 }
39811 arg2 = static_cast< int >(val2);
39812 {
39813 PyThreadState* __tstate = wxPyBeginAllowThreads();
39814 result = (bool)(arg1)->Destroy(arg2);
39815 wxPyEndAllowThreads(__tstate);
39816 if (PyErr_Occurred()) SWIG_fail;
39817 }
39818 {
39819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39820 }
39821 return resultobj;
39822 fail:
39823 return NULL;
39824 }
39825
39826
39827 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39828 PyObject *resultobj = 0;
39829 wxMenu *arg1 = (wxMenu *) 0 ;
39830 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39831 bool result;
39832 void *argp1 = 0 ;
39833 int res1 = 0 ;
39834 void *argp2 = 0 ;
39835 int res2 = 0 ;
39836 PyObject * obj0 = 0 ;
39837 PyObject * obj1 = 0 ;
39838 char * kwnames[] = {
39839 (char *) "self",(char *) "item", NULL
39840 };
39841
39842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39844 if (!SWIG_IsOK(res1)) {
39845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39846 }
39847 arg1 = reinterpret_cast< wxMenu * >(argp1);
39848 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39849 if (!SWIG_IsOK(res2)) {
39850 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39851 }
39852 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39853 {
39854 PyThreadState* __tstate = wxPyBeginAllowThreads();
39855 result = (bool)(arg1)->Destroy(arg2);
39856 wxPyEndAllowThreads(__tstate);
39857 if (PyErr_Occurred()) SWIG_fail;
39858 }
39859 {
39860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39861 }
39862 return resultobj;
39863 fail:
39864 return NULL;
39865 }
39866
39867
39868 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39869 PyObject *resultobj = 0;
39870 wxMenu *arg1 = (wxMenu *) 0 ;
39871 size_t result;
39872 void *argp1 = 0 ;
39873 int res1 = 0 ;
39874 PyObject *swig_obj[1] ;
39875
39876 if (!args) SWIG_fail;
39877 swig_obj[0] = args;
39878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39879 if (!SWIG_IsOK(res1)) {
39880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39881 }
39882 arg1 = reinterpret_cast< wxMenu * >(argp1);
39883 {
39884 PyThreadState* __tstate = wxPyBeginAllowThreads();
39885 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39886 wxPyEndAllowThreads(__tstate);
39887 if (PyErr_Occurred()) SWIG_fail;
39888 }
39889 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39890 return resultobj;
39891 fail:
39892 return NULL;
39893 }
39894
39895
39896 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39897 PyObject *resultobj = 0;
39898 wxMenu *arg1 = (wxMenu *) 0 ;
39899 PyObject *result = 0 ;
39900 void *argp1 = 0 ;
39901 int res1 = 0 ;
39902 PyObject *swig_obj[1] ;
39903
39904 if (!args) SWIG_fail;
39905 swig_obj[0] = args;
39906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39907 if (!SWIG_IsOK(res1)) {
39908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39909 }
39910 arg1 = reinterpret_cast< wxMenu * >(argp1);
39911 {
39912 PyThreadState* __tstate = wxPyBeginAllowThreads();
39913 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39914 wxPyEndAllowThreads(__tstate);
39915 if (PyErr_Occurred()) SWIG_fail;
39916 }
39917 resultobj = result;
39918 return resultobj;
39919 fail:
39920 return NULL;
39921 }
39922
39923
39924 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39925 PyObject *resultobj = 0;
39926 wxMenu *arg1 = (wxMenu *) 0 ;
39927 wxString *arg2 = 0 ;
39928 int result;
39929 void *argp1 = 0 ;
39930 int res1 = 0 ;
39931 bool temp2 = false ;
39932 PyObject * obj0 = 0 ;
39933 PyObject * obj1 = 0 ;
39934 char * kwnames[] = {
39935 (char *) "self",(char *) "item", NULL
39936 };
39937
39938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39940 if (!SWIG_IsOK(res1)) {
39941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39942 }
39943 arg1 = reinterpret_cast< wxMenu * >(argp1);
39944 {
39945 arg2 = wxString_in_helper(obj1);
39946 if (arg2 == NULL) SWIG_fail;
39947 temp2 = true;
39948 }
39949 {
39950 PyThreadState* __tstate = wxPyBeginAllowThreads();
39951 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39952 wxPyEndAllowThreads(__tstate);
39953 if (PyErr_Occurred()) SWIG_fail;
39954 }
39955 resultobj = SWIG_From_int(static_cast< int >(result));
39956 {
39957 if (temp2)
39958 delete arg2;
39959 }
39960 return resultobj;
39961 fail:
39962 {
39963 if (temp2)
39964 delete arg2;
39965 }
39966 return NULL;
39967 }
39968
39969
39970 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39971 PyObject *resultobj = 0;
39972 wxMenu *arg1 = (wxMenu *) 0 ;
39973 int arg2 ;
39974 wxMenuItem *result = 0 ;
39975 void *argp1 = 0 ;
39976 int res1 = 0 ;
39977 int val2 ;
39978 int ecode2 = 0 ;
39979 PyObject * obj0 = 0 ;
39980 PyObject * obj1 = 0 ;
39981 char * kwnames[] = {
39982 (char *) "self",(char *) "id", NULL
39983 };
39984
39985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39987 if (!SWIG_IsOK(res1)) {
39988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39989 }
39990 arg1 = reinterpret_cast< wxMenu * >(argp1);
39991 ecode2 = SWIG_AsVal_int(obj1, &val2);
39992 if (!SWIG_IsOK(ecode2)) {
39993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39994 }
39995 arg2 = static_cast< int >(val2);
39996 {
39997 PyThreadState* __tstate = wxPyBeginAllowThreads();
39998 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39999 wxPyEndAllowThreads(__tstate);
40000 if (PyErr_Occurred()) SWIG_fail;
40001 }
40002 {
40003 resultobj = wxPyMake_wxObject(result, (bool)0);
40004 }
40005 return resultobj;
40006 fail:
40007 return NULL;
40008 }
40009
40010
40011 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40012 PyObject *resultobj = 0;
40013 wxMenu *arg1 = (wxMenu *) 0 ;
40014 size_t arg2 ;
40015 wxMenuItem *result = 0 ;
40016 void *argp1 = 0 ;
40017 int res1 = 0 ;
40018 size_t val2 ;
40019 int ecode2 = 0 ;
40020 PyObject * obj0 = 0 ;
40021 PyObject * obj1 = 0 ;
40022 char * kwnames[] = {
40023 (char *) "self",(char *) "position", NULL
40024 };
40025
40026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40028 if (!SWIG_IsOK(res1)) {
40029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40030 }
40031 arg1 = reinterpret_cast< wxMenu * >(argp1);
40032 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40033 if (!SWIG_IsOK(ecode2)) {
40034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40035 }
40036 arg2 = static_cast< size_t >(val2);
40037 {
40038 PyThreadState* __tstate = wxPyBeginAllowThreads();
40039 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40040 wxPyEndAllowThreads(__tstate);
40041 if (PyErr_Occurred()) SWIG_fail;
40042 }
40043 {
40044 resultobj = wxPyMake_wxObject(result, (bool)0);
40045 }
40046 return resultobj;
40047 fail:
40048 return NULL;
40049 }
40050
40051
40052 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40053 PyObject *resultobj = 0;
40054 wxMenu *arg1 = (wxMenu *) 0 ;
40055 int arg2 ;
40056 bool arg3 ;
40057 void *argp1 = 0 ;
40058 int res1 = 0 ;
40059 int val2 ;
40060 int ecode2 = 0 ;
40061 bool val3 ;
40062 int ecode3 = 0 ;
40063 PyObject * obj0 = 0 ;
40064 PyObject * obj1 = 0 ;
40065 PyObject * obj2 = 0 ;
40066 char * kwnames[] = {
40067 (char *) "self",(char *) "id",(char *) "enable", NULL
40068 };
40069
40070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40072 if (!SWIG_IsOK(res1)) {
40073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40074 }
40075 arg1 = reinterpret_cast< wxMenu * >(argp1);
40076 ecode2 = SWIG_AsVal_int(obj1, &val2);
40077 if (!SWIG_IsOK(ecode2)) {
40078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40079 }
40080 arg2 = static_cast< int >(val2);
40081 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40082 if (!SWIG_IsOK(ecode3)) {
40083 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40084 }
40085 arg3 = static_cast< bool >(val3);
40086 {
40087 PyThreadState* __tstate = wxPyBeginAllowThreads();
40088 (arg1)->Enable(arg2,arg3);
40089 wxPyEndAllowThreads(__tstate);
40090 if (PyErr_Occurred()) SWIG_fail;
40091 }
40092 resultobj = SWIG_Py_Void();
40093 return resultobj;
40094 fail:
40095 return NULL;
40096 }
40097
40098
40099 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40100 PyObject *resultobj = 0;
40101 wxMenu *arg1 = (wxMenu *) 0 ;
40102 int arg2 ;
40103 bool result;
40104 void *argp1 = 0 ;
40105 int res1 = 0 ;
40106 int val2 ;
40107 int ecode2 = 0 ;
40108 PyObject * obj0 = 0 ;
40109 PyObject * obj1 = 0 ;
40110 char * kwnames[] = {
40111 (char *) "self",(char *) "id", NULL
40112 };
40113
40114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40116 if (!SWIG_IsOK(res1)) {
40117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40118 }
40119 arg1 = reinterpret_cast< wxMenu * >(argp1);
40120 ecode2 = SWIG_AsVal_int(obj1, &val2);
40121 if (!SWIG_IsOK(ecode2)) {
40122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40123 }
40124 arg2 = static_cast< int >(val2);
40125 {
40126 PyThreadState* __tstate = wxPyBeginAllowThreads();
40127 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40128 wxPyEndAllowThreads(__tstate);
40129 if (PyErr_Occurred()) SWIG_fail;
40130 }
40131 {
40132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40133 }
40134 return resultobj;
40135 fail:
40136 return NULL;
40137 }
40138
40139
40140 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40141 PyObject *resultobj = 0;
40142 wxMenu *arg1 = (wxMenu *) 0 ;
40143 int arg2 ;
40144 bool arg3 ;
40145 void *argp1 = 0 ;
40146 int res1 = 0 ;
40147 int val2 ;
40148 int ecode2 = 0 ;
40149 bool val3 ;
40150 int ecode3 = 0 ;
40151 PyObject * obj0 = 0 ;
40152 PyObject * obj1 = 0 ;
40153 PyObject * obj2 = 0 ;
40154 char * kwnames[] = {
40155 (char *) "self",(char *) "id",(char *) "check", NULL
40156 };
40157
40158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40160 if (!SWIG_IsOK(res1)) {
40161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40162 }
40163 arg1 = reinterpret_cast< wxMenu * >(argp1);
40164 ecode2 = SWIG_AsVal_int(obj1, &val2);
40165 if (!SWIG_IsOK(ecode2)) {
40166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40167 }
40168 arg2 = static_cast< int >(val2);
40169 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40170 if (!SWIG_IsOK(ecode3)) {
40171 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40172 }
40173 arg3 = static_cast< bool >(val3);
40174 {
40175 PyThreadState* __tstate = wxPyBeginAllowThreads();
40176 (arg1)->Check(arg2,arg3);
40177 wxPyEndAllowThreads(__tstate);
40178 if (PyErr_Occurred()) SWIG_fail;
40179 }
40180 resultobj = SWIG_Py_Void();
40181 return resultobj;
40182 fail:
40183 return NULL;
40184 }
40185
40186
40187 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40188 PyObject *resultobj = 0;
40189 wxMenu *arg1 = (wxMenu *) 0 ;
40190 int arg2 ;
40191 bool result;
40192 void *argp1 = 0 ;
40193 int res1 = 0 ;
40194 int val2 ;
40195 int ecode2 = 0 ;
40196 PyObject * obj0 = 0 ;
40197 PyObject * obj1 = 0 ;
40198 char * kwnames[] = {
40199 (char *) "self",(char *) "id", NULL
40200 };
40201
40202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40204 if (!SWIG_IsOK(res1)) {
40205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40206 }
40207 arg1 = reinterpret_cast< wxMenu * >(argp1);
40208 ecode2 = SWIG_AsVal_int(obj1, &val2);
40209 if (!SWIG_IsOK(ecode2)) {
40210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40211 }
40212 arg2 = static_cast< int >(val2);
40213 {
40214 PyThreadState* __tstate = wxPyBeginAllowThreads();
40215 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40216 wxPyEndAllowThreads(__tstate);
40217 if (PyErr_Occurred()) SWIG_fail;
40218 }
40219 {
40220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40221 }
40222 return resultobj;
40223 fail:
40224 return NULL;
40225 }
40226
40227
40228 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40229 PyObject *resultobj = 0;
40230 wxMenu *arg1 = (wxMenu *) 0 ;
40231 int arg2 ;
40232 wxString *arg3 = 0 ;
40233 void *argp1 = 0 ;
40234 int res1 = 0 ;
40235 int val2 ;
40236 int ecode2 = 0 ;
40237 bool temp3 = false ;
40238 PyObject * obj0 = 0 ;
40239 PyObject * obj1 = 0 ;
40240 PyObject * obj2 = 0 ;
40241 char * kwnames[] = {
40242 (char *) "self",(char *) "id",(char *) "label", NULL
40243 };
40244
40245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40247 if (!SWIG_IsOK(res1)) {
40248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40249 }
40250 arg1 = reinterpret_cast< wxMenu * >(argp1);
40251 ecode2 = SWIG_AsVal_int(obj1, &val2);
40252 if (!SWIG_IsOK(ecode2)) {
40253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40254 }
40255 arg2 = static_cast< int >(val2);
40256 {
40257 arg3 = wxString_in_helper(obj2);
40258 if (arg3 == NULL) SWIG_fail;
40259 temp3 = true;
40260 }
40261 {
40262 PyThreadState* __tstate = wxPyBeginAllowThreads();
40263 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40264 wxPyEndAllowThreads(__tstate);
40265 if (PyErr_Occurred()) SWIG_fail;
40266 }
40267 resultobj = SWIG_Py_Void();
40268 {
40269 if (temp3)
40270 delete arg3;
40271 }
40272 return resultobj;
40273 fail:
40274 {
40275 if (temp3)
40276 delete arg3;
40277 }
40278 return NULL;
40279 }
40280
40281
40282 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40283 PyObject *resultobj = 0;
40284 wxMenu *arg1 = (wxMenu *) 0 ;
40285 int arg2 ;
40286 wxString result;
40287 void *argp1 = 0 ;
40288 int res1 = 0 ;
40289 int val2 ;
40290 int ecode2 = 0 ;
40291 PyObject * obj0 = 0 ;
40292 PyObject * obj1 = 0 ;
40293 char * kwnames[] = {
40294 (char *) "self",(char *) "id", NULL
40295 };
40296
40297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40299 if (!SWIG_IsOK(res1)) {
40300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40301 }
40302 arg1 = reinterpret_cast< wxMenu * >(argp1);
40303 ecode2 = SWIG_AsVal_int(obj1, &val2);
40304 if (!SWIG_IsOK(ecode2)) {
40305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40306 }
40307 arg2 = static_cast< int >(val2);
40308 {
40309 PyThreadState* __tstate = wxPyBeginAllowThreads();
40310 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40311 wxPyEndAllowThreads(__tstate);
40312 if (PyErr_Occurred()) SWIG_fail;
40313 }
40314 {
40315 #if wxUSE_UNICODE
40316 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40317 #else
40318 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40319 #endif
40320 }
40321 return resultobj;
40322 fail:
40323 return NULL;
40324 }
40325
40326
40327 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40328 PyObject *resultobj = 0;
40329 wxMenu *arg1 = (wxMenu *) 0 ;
40330 int arg2 ;
40331 wxString *arg3 = 0 ;
40332 void *argp1 = 0 ;
40333 int res1 = 0 ;
40334 int val2 ;
40335 int ecode2 = 0 ;
40336 bool temp3 = false ;
40337 PyObject * obj0 = 0 ;
40338 PyObject * obj1 = 0 ;
40339 PyObject * obj2 = 0 ;
40340 char * kwnames[] = {
40341 (char *) "self",(char *) "id",(char *) "helpString", NULL
40342 };
40343
40344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40346 if (!SWIG_IsOK(res1)) {
40347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40348 }
40349 arg1 = reinterpret_cast< wxMenu * >(argp1);
40350 ecode2 = SWIG_AsVal_int(obj1, &val2);
40351 if (!SWIG_IsOK(ecode2)) {
40352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40353 }
40354 arg2 = static_cast< int >(val2);
40355 {
40356 arg3 = wxString_in_helper(obj2);
40357 if (arg3 == NULL) SWIG_fail;
40358 temp3 = true;
40359 }
40360 {
40361 PyThreadState* __tstate = wxPyBeginAllowThreads();
40362 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40363 wxPyEndAllowThreads(__tstate);
40364 if (PyErr_Occurred()) SWIG_fail;
40365 }
40366 resultobj = SWIG_Py_Void();
40367 {
40368 if (temp3)
40369 delete arg3;
40370 }
40371 return resultobj;
40372 fail:
40373 {
40374 if (temp3)
40375 delete arg3;
40376 }
40377 return NULL;
40378 }
40379
40380
40381 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40382 PyObject *resultobj = 0;
40383 wxMenu *arg1 = (wxMenu *) 0 ;
40384 int arg2 ;
40385 wxString result;
40386 void *argp1 = 0 ;
40387 int res1 = 0 ;
40388 int val2 ;
40389 int ecode2 = 0 ;
40390 PyObject * obj0 = 0 ;
40391 PyObject * obj1 = 0 ;
40392 char * kwnames[] = {
40393 (char *) "self",(char *) "id", NULL
40394 };
40395
40396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40398 if (!SWIG_IsOK(res1)) {
40399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40400 }
40401 arg1 = reinterpret_cast< wxMenu * >(argp1);
40402 ecode2 = SWIG_AsVal_int(obj1, &val2);
40403 if (!SWIG_IsOK(ecode2)) {
40404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40405 }
40406 arg2 = static_cast< int >(val2);
40407 {
40408 PyThreadState* __tstate = wxPyBeginAllowThreads();
40409 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40410 wxPyEndAllowThreads(__tstate);
40411 if (PyErr_Occurred()) SWIG_fail;
40412 }
40413 {
40414 #if wxUSE_UNICODE
40415 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40416 #else
40417 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40418 #endif
40419 }
40420 return resultobj;
40421 fail:
40422 return NULL;
40423 }
40424
40425
40426 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40427 PyObject *resultobj = 0;
40428 wxMenu *arg1 = (wxMenu *) 0 ;
40429 wxString *arg2 = 0 ;
40430 void *argp1 = 0 ;
40431 int res1 = 0 ;
40432 bool temp2 = false ;
40433 PyObject * obj0 = 0 ;
40434 PyObject * obj1 = 0 ;
40435 char * kwnames[] = {
40436 (char *) "self",(char *) "title", NULL
40437 };
40438
40439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40441 if (!SWIG_IsOK(res1)) {
40442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40443 }
40444 arg1 = reinterpret_cast< wxMenu * >(argp1);
40445 {
40446 arg2 = wxString_in_helper(obj1);
40447 if (arg2 == NULL) SWIG_fail;
40448 temp2 = true;
40449 }
40450 {
40451 PyThreadState* __tstate = wxPyBeginAllowThreads();
40452 (arg1)->SetTitle((wxString const &)*arg2);
40453 wxPyEndAllowThreads(__tstate);
40454 if (PyErr_Occurred()) SWIG_fail;
40455 }
40456 resultobj = SWIG_Py_Void();
40457 {
40458 if (temp2)
40459 delete arg2;
40460 }
40461 return resultobj;
40462 fail:
40463 {
40464 if (temp2)
40465 delete arg2;
40466 }
40467 return NULL;
40468 }
40469
40470
40471 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40472 PyObject *resultobj = 0;
40473 wxMenu *arg1 = (wxMenu *) 0 ;
40474 wxString result;
40475 void *argp1 = 0 ;
40476 int res1 = 0 ;
40477 PyObject *swig_obj[1] ;
40478
40479 if (!args) SWIG_fail;
40480 swig_obj[0] = args;
40481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40482 if (!SWIG_IsOK(res1)) {
40483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40484 }
40485 arg1 = reinterpret_cast< wxMenu * >(argp1);
40486 {
40487 PyThreadState* __tstate = wxPyBeginAllowThreads();
40488 result = ((wxMenu const *)arg1)->GetTitle();
40489 wxPyEndAllowThreads(__tstate);
40490 if (PyErr_Occurred()) SWIG_fail;
40491 }
40492 {
40493 #if wxUSE_UNICODE
40494 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40495 #else
40496 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40497 #endif
40498 }
40499 return resultobj;
40500 fail:
40501 return NULL;
40502 }
40503
40504
40505 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40506 PyObject *resultobj = 0;
40507 wxMenu *arg1 = (wxMenu *) 0 ;
40508 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40509 void *argp1 = 0 ;
40510 int res1 = 0 ;
40511 void *argp2 = 0 ;
40512 int res2 = 0 ;
40513 PyObject * obj0 = 0 ;
40514 PyObject * obj1 = 0 ;
40515 char * kwnames[] = {
40516 (char *) "self",(char *) "handler", NULL
40517 };
40518
40519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40521 if (!SWIG_IsOK(res1)) {
40522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40523 }
40524 arg1 = reinterpret_cast< wxMenu * >(argp1);
40525 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40526 if (!SWIG_IsOK(res2)) {
40527 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40528 }
40529 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40530 {
40531 PyThreadState* __tstate = wxPyBeginAllowThreads();
40532 (arg1)->SetEventHandler(arg2);
40533 wxPyEndAllowThreads(__tstate);
40534 if (PyErr_Occurred()) SWIG_fail;
40535 }
40536 resultobj = SWIG_Py_Void();
40537 return resultobj;
40538 fail:
40539 return NULL;
40540 }
40541
40542
40543 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40544 PyObject *resultobj = 0;
40545 wxMenu *arg1 = (wxMenu *) 0 ;
40546 wxEvtHandler *result = 0 ;
40547 void *argp1 = 0 ;
40548 int res1 = 0 ;
40549 PyObject *swig_obj[1] ;
40550
40551 if (!args) SWIG_fail;
40552 swig_obj[0] = args;
40553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40554 if (!SWIG_IsOK(res1)) {
40555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40556 }
40557 arg1 = reinterpret_cast< wxMenu * >(argp1);
40558 {
40559 PyThreadState* __tstate = wxPyBeginAllowThreads();
40560 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40561 wxPyEndAllowThreads(__tstate);
40562 if (PyErr_Occurred()) SWIG_fail;
40563 }
40564 {
40565 resultobj = wxPyMake_wxObject(result, 0);
40566 }
40567 return resultobj;
40568 fail:
40569 return NULL;
40570 }
40571
40572
40573 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40574 PyObject *resultobj = 0;
40575 wxMenu *arg1 = (wxMenu *) 0 ;
40576 wxWindow *arg2 = (wxWindow *) 0 ;
40577 void *argp1 = 0 ;
40578 int res1 = 0 ;
40579 void *argp2 = 0 ;
40580 int res2 = 0 ;
40581 PyObject * obj0 = 0 ;
40582 PyObject * obj1 = 0 ;
40583 char * kwnames[] = {
40584 (char *) "self",(char *) "win", NULL
40585 };
40586
40587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40589 if (!SWIG_IsOK(res1)) {
40590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40591 }
40592 arg1 = reinterpret_cast< wxMenu * >(argp1);
40593 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40594 if (!SWIG_IsOK(res2)) {
40595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40596 }
40597 arg2 = reinterpret_cast< wxWindow * >(argp2);
40598 {
40599 PyThreadState* __tstate = wxPyBeginAllowThreads();
40600 (arg1)->SetInvokingWindow(arg2);
40601 wxPyEndAllowThreads(__tstate);
40602 if (PyErr_Occurred()) SWIG_fail;
40603 }
40604 resultobj = SWIG_Py_Void();
40605 return resultobj;
40606 fail:
40607 return NULL;
40608 }
40609
40610
40611 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40612 PyObject *resultobj = 0;
40613 wxMenu *arg1 = (wxMenu *) 0 ;
40614 wxWindow *result = 0 ;
40615 void *argp1 = 0 ;
40616 int res1 = 0 ;
40617 PyObject *swig_obj[1] ;
40618
40619 if (!args) SWIG_fail;
40620 swig_obj[0] = args;
40621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40622 if (!SWIG_IsOK(res1)) {
40623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40624 }
40625 arg1 = reinterpret_cast< wxMenu * >(argp1);
40626 {
40627 PyThreadState* __tstate = wxPyBeginAllowThreads();
40628 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40629 wxPyEndAllowThreads(__tstate);
40630 if (PyErr_Occurred()) SWIG_fail;
40631 }
40632 {
40633 resultobj = wxPyMake_wxObject(result, 0);
40634 }
40635 return resultobj;
40636 fail:
40637 return NULL;
40638 }
40639
40640
40641 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40642 PyObject *resultobj = 0;
40643 wxMenu *arg1 = (wxMenu *) 0 ;
40644 long result;
40645 void *argp1 = 0 ;
40646 int res1 = 0 ;
40647 PyObject *swig_obj[1] ;
40648
40649 if (!args) SWIG_fail;
40650 swig_obj[0] = args;
40651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40652 if (!SWIG_IsOK(res1)) {
40653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40654 }
40655 arg1 = reinterpret_cast< wxMenu * >(argp1);
40656 {
40657 PyThreadState* __tstate = wxPyBeginAllowThreads();
40658 result = (long)((wxMenu const *)arg1)->GetStyle();
40659 wxPyEndAllowThreads(__tstate);
40660 if (PyErr_Occurred()) SWIG_fail;
40661 }
40662 resultobj = SWIG_From_long(static_cast< long >(result));
40663 return resultobj;
40664 fail:
40665 return NULL;
40666 }
40667
40668
40669 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40670 PyObject *resultobj = 0;
40671 wxMenu *arg1 = (wxMenu *) 0 ;
40672 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40673 void *argp1 = 0 ;
40674 int res1 = 0 ;
40675 void *argp2 = 0 ;
40676 int res2 = 0 ;
40677 PyObject * obj0 = 0 ;
40678 PyObject * obj1 = 0 ;
40679 char * kwnames[] = {
40680 (char *) "self",(char *) "source", NULL
40681 };
40682
40683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40685 if (!SWIG_IsOK(res1)) {
40686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40687 }
40688 arg1 = reinterpret_cast< wxMenu * >(argp1);
40689 if (obj1) {
40690 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40691 if (!SWIG_IsOK(res2)) {
40692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40693 }
40694 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40695 }
40696 {
40697 PyThreadState* __tstate = wxPyBeginAllowThreads();
40698 (arg1)->UpdateUI(arg2);
40699 wxPyEndAllowThreads(__tstate);
40700 if (PyErr_Occurred()) SWIG_fail;
40701 }
40702 resultobj = SWIG_Py_Void();
40703 return resultobj;
40704 fail:
40705 return NULL;
40706 }
40707
40708
40709 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40710 PyObject *resultobj = 0;
40711 wxMenu *arg1 = (wxMenu *) 0 ;
40712 wxMenuBar *result = 0 ;
40713 void *argp1 = 0 ;
40714 int res1 = 0 ;
40715 PyObject *swig_obj[1] ;
40716
40717 if (!args) SWIG_fail;
40718 swig_obj[0] = args;
40719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40720 if (!SWIG_IsOK(res1)) {
40721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40722 }
40723 arg1 = reinterpret_cast< wxMenu * >(argp1);
40724 {
40725 PyThreadState* __tstate = wxPyBeginAllowThreads();
40726 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40727 wxPyEndAllowThreads(__tstate);
40728 if (PyErr_Occurred()) SWIG_fail;
40729 }
40730 {
40731 resultobj = wxPyMake_wxObject(result, (bool)0);
40732 }
40733 return resultobj;
40734 fail:
40735 return NULL;
40736 }
40737
40738
40739 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40740 PyObject *resultobj = 0;
40741 wxMenu *arg1 = (wxMenu *) 0 ;
40742 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40743 void *argp1 = 0 ;
40744 int res1 = 0 ;
40745 void *argp2 = 0 ;
40746 int res2 = 0 ;
40747 PyObject * obj0 = 0 ;
40748 PyObject * obj1 = 0 ;
40749 char * kwnames[] = {
40750 (char *) "self",(char *) "menubar", NULL
40751 };
40752
40753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40755 if (!SWIG_IsOK(res1)) {
40756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40757 }
40758 arg1 = reinterpret_cast< wxMenu * >(argp1);
40759 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40760 if (!SWIG_IsOK(res2)) {
40761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40762 }
40763 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40764 {
40765 PyThreadState* __tstate = wxPyBeginAllowThreads();
40766 (arg1)->Attach(arg2);
40767 wxPyEndAllowThreads(__tstate);
40768 if (PyErr_Occurred()) SWIG_fail;
40769 }
40770 resultobj = SWIG_Py_Void();
40771 return resultobj;
40772 fail:
40773 return NULL;
40774 }
40775
40776
40777 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40778 PyObject *resultobj = 0;
40779 wxMenu *arg1 = (wxMenu *) 0 ;
40780 void *argp1 = 0 ;
40781 int res1 = 0 ;
40782 PyObject *swig_obj[1] ;
40783
40784 if (!args) SWIG_fail;
40785 swig_obj[0] = args;
40786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40787 if (!SWIG_IsOK(res1)) {
40788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40789 }
40790 arg1 = reinterpret_cast< wxMenu * >(argp1);
40791 {
40792 PyThreadState* __tstate = wxPyBeginAllowThreads();
40793 (arg1)->Detach();
40794 wxPyEndAllowThreads(__tstate);
40795 if (PyErr_Occurred()) SWIG_fail;
40796 }
40797 resultobj = SWIG_Py_Void();
40798 return resultobj;
40799 fail:
40800 return NULL;
40801 }
40802
40803
40804 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40805 PyObject *resultobj = 0;
40806 wxMenu *arg1 = (wxMenu *) 0 ;
40807 bool result;
40808 void *argp1 = 0 ;
40809 int res1 = 0 ;
40810 PyObject *swig_obj[1] ;
40811
40812 if (!args) SWIG_fail;
40813 swig_obj[0] = args;
40814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40815 if (!SWIG_IsOK(res1)) {
40816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40817 }
40818 arg1 = reinterpret_cast< wxMenu * >(argp1);
40819 {
40820 PyThreadState* __tstate = wxPyBeginAllowThreads();
40821 result = (bool)((wxMenu const *)arg1)->IsAttached();
40822 wxPyEndAllowThreads(__tstate);
40823 if (PyErr_Occurred()) SWIG_fail;
40824 }
40825 {
40826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40827 }
40828 return resultobj;
40829 fail:
40830 return NULL;
40831 }
40832
40833
40834 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40835 PyObject *resultobj = 0;
40836 wxMenu *arg1 = (wxMenu *) 0 ;
40837 wxMenu *arg2 = (wxMenu *) 0 ;
40838 void *argp1 = 0 ;
40839 int res1 = 0 ;
40840 void *argp2 = 0 ;
40841 int res2 = 0 ;
40842 PyObject * obj0 = 0 ;
40843 PyObject * obj1 = 0 ;
40844 char * kwnames[] = {
40845 (char *) "self",(char *) "parent", NULL
40846 };
40847
40848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40850 if (!SWIG_IsOK(res1)) {
40851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40852 }
40853 arg1 = reinterpret_cast< wxMenu * >(argp1);
40854 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40855 if (!SWIG_IsOK(res2)) {
40856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40857 }
40858 arg2 = reinterpret_cast< wxMenu * >(argp2);
40859 {
40860 PyThreadState* __tstate = wxPyBeginAllowThreads();
40861 (arg1)->SetParent(arg2);
40862 wxPyEndAllowThreads(__tstate);
40863 if (PyErr_Occurred()) SWIG_fail;
40864 }
40865 resultobj = SWIG_Py_Void();
40866 return resultobj;
40867 fail:
40868 return NULL;
40869 }
40870
40871
40872 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40873 PyObject *resultobj = 0;
40874 wxMenu *arg1 = (wxMenu *) 0 ;
40875 wxMenu *result = 0 ;
40876 void *argp1 = 0 ;
40877 int res1 = 0 ;
40878 PyObject *swig_obj[1] ;
40879
40880 if (!args) SWIG_fail;
40881 swig_obj[0] = args;
40882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40883 if (!SWIG_IsOK(res1)) {
40884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40885 }
40886 arg1 = reinterpret_cast< wxMenu * >(argp1);
40887 {
40888 PyThreadState* __tstate = wxPyBeginAllowThreads();
40889 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40890 wxPyEndAllowThreads(__tstate);
40891 if (PyErr_Occurred()) SWIG_fail;
40892 }
40893 {
40894 resultobj = wxPyMake_wxObject(result, 0);
40895 }
40896 return resultobj;
40897 fail:
40898 return NULL;
40899 }
40900
40901
40902 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40903 PyObject *obj;
40904 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40905 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40906 return SWIG_Py_Void();
40907 }
40908
40909 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40910 return SWIG_Python_InitShadowInstance(args);
40911 }
40912
40913 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40914 PyObject *resultobj = 0;
40915 long arg1 = (long) 0 ;
40916 wxMenuBar *result = 0 ;
40917 long val1 ;
40918 int ecode1 = 0 ;
40919 PyObject * obj0 = 0 ;
40920 char * kwnames[] = {
40921 (char *) "style", NULL
40922 };
40923
40924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40925 if (obj0) {
40926 ecode1 = SWIG_AsVal_long(obj0, &val1);
40927 if (!SWIG_IsOK(ecode1)) {
40928 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40929 }
40930 arg1 = static_cast< long >(val1);
40931 }
40932 {
40933 if (!wxPyCheckForApp()) SWIG_fail;
40934 PyThreadState* __tstate = wxPyBeginAllowThreads();
40935 result = (wxMenuBar *)new wxMenuBar(arg1);
40936 wxPyEndAllowThreads(__tstate);
40937 if (PyErr_Occurred()) SWIG_fail;
40938 }
40939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40940 return resultobj;
40941 fail:
40942 return NULL;
40943 }
40944
40945
40946 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40947 PyObject *resultobj = 0;
40948 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40949 wxMenu *arg2 = (wxMenu *) 0 ;
40950 wxString *arg3 = 0 ;
40951 bool result;
40952 void *argp1 = 0 ;
40953 int res1 = 0 ;
40954 void *argp2 = 0 ;
40955 int res2 = 0 ;
40956 bool temp3 = false ;
40957 PyObject * obj0 = 0 ;
40958 PyObject * obj1 = 0 ;
40959 PyObject * obj2 = 0 ;
40960 char * kwnames[] = {
40961 (char *) "self",(char *) "menu",(char *) "title", NULL
40962 };
40963
40964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40966 if (!SWIG_IsOK(res1)) {
40967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40968 }
40969 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40970 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40971 if (!SWIG_IsOK(res2)) {
40972 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40973 }
40974 arg2 = reinterpret_cast< wxMenu * >(argp2);
40975 {
40976 arg3 = wxString_in_helper(obj2);
40977 if (arg3 == NULL) SWIG_fail;
40978 temp3 = true;
40979 }
40980 {
40981 PyThreadState* __tstate = wxPyBeginAllowThreads();
40982 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40983 wxPyEndAllowThreads(__tstate);
40984 if (PyErr_Occurred()) SWIG_fail;
40985 }
40986 {
40987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40988 }
40989 {
40990 if (temp3)
40991 delete arg3;
40992 }
40993 return resultobj;
40994 fail:
40995 {
40996 if (temp3)
40997 delete arg3;
40998 }
40999 return NULL;
41000 }
41001
41002
41003 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41004 PyObject *resultobj = 0;
41005 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41006 size_t arg2 ;
41007 wxMenu *arg3 = (wxMenu *) 0 ;
41008 wxString *arg4 = 0 ;
41009 bool result;
41010 void *argp1 = 0 ;
41011 int res1 = 0 ;
41012 size_t val2 ;
41013 int ecode2 = 0 ;
41014 void *argp3 = 0 ;
41015 int res3 = 0 ;
41016 bool temp4 = false ;
41017 PyObject * obj0 = 0 ;
41018 PyObject * obj1 = 0 ;
41019 PyObject * obj2 = 0 ;
41020 PyObject * obj3 = 0 ;
41021 char * kwnames[] = {
41022 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41023 };
41024
41025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41027 if (!SWIG_IsOK(res1)) {
41028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41029 }
41030 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41031 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41032 if (!SWIG_IsOK(ecode2)) {
41033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41034 }
41035 arg2 = static_cast< size_t >(val2);
41036 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41037 if (!SWIG_IsOK(res3)) {
41038 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41039 }
41040 arg3 = reinterpret_cast< wxMenu * >(argp3);
41041 {
41042 arg4 = wxString_in_helper(obj3);
41043 if (arg4 == NULL) SWIG_fail;
41044 temp4 = true;
41045 }
41046 {
41047 PyThreadState* __tstate = wxPyBeginAllowThreads();
41048 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41049 wxPyEndAllowThreads(__tstate);
41050 if (PyErr_Occurred()) SWIG_fail;
41051 }
41052 {
41053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41054 }
41055 {
41056 if (temp4)
41057 delete arg4;
41058 }
41059 return resultobj;
41060 fail:
41061 {
41062 if (temp4)
41063 delete arg4;
41064 }
41065 return NULL;
41066 }
41067
41068
41069 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41070 PyObject *resultobj = 0;
41071 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41072 size_t result;
41073 void *argp1 = 0 ;
41074 int res1 = 0 ;
41075 PyObject *swig_obj[1] ;
41076
41077 if (!args) SWIG_fail;
41078 swig_obj[0] = args;
41079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41080 if (!SWIG_IsOK(res1)) {
41081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41082 }
41083 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41084 {
41085 PyThreadState* __tstate = wxPyBeginAllowThreads();
41086 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41087 wxPyEndAllowThreads(__tstate);
41088 if (PyErr_Occurred()) SWIG_fail;
41089 }
41090 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41091 return resultobj;
41092 fail:
41093 return NULL;
41094 }
41095
41096
41097 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41098 PyObject *resultobj = 0;
41099 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41100 size_t arg2 ;
41101 wxMenu *result = 0 ;
41102 void *argp1 = 0 ;
41103 int res1 = 0 ;
41104 size_t val2 ;
41105 int ecode2 = 0 ;
41106 PyObject * obj0 = 0 ;
41107 PyObject * obj1 = 0 ;
41108 char * kwnames[] = {
41109 (char *) "self",(char *) "pos", NULL
41110 };
41111
41112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41114 if (!SWIG_IsOK(res1)) {
41115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41116 }
41117 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41118 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41119 if (!SWIG_IsOK(ecode2)) {
41120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41121 }
41122 arg2 = static_cast< size_t >(val2);
41123 {
41124 PyThreadState* __tstate = wxPyBeginAllowThreads();
41125 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41126 wxPyEndAllowThreads(__tstate);
41127 if (PyErr_Occurred()) SWIG_fail;
41128 }
41129 {
41130 resultobj = wxPyMake_wxObject(result, 0);
41131 }
41132 return resultobj;
41133 fail:
41134 return NULL;
41135 }
41136
41137
41138 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41139 PyObject *resultobj = 0;
41140 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41141 size_t arg2 ;
41142 wxMenu *arg3 = (wxMenu *) 0 ;
41143 wxString *arg4 = 0 ;
41144 wxMenu *result = 0 ;
41145 void *argp1 = 0 ;
41146 int res1 = 0 ;
41147 size_t val2 ;
41148 int ecode2 = 0 ;
41149 void *argp3 = 0 ;
41150 int res3 = 0 ;
41151 bool temp4 = false ;
41152 PyObject * obj0 = 0 ;
41153 PyObject * obj1 = 0 ;
41154 PyObject * obj2 = 0 ;
41155 PyObject * obj3 = 0 ;
41156 char * kwnames[] = {
41157 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41158 };
41159
41160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41162 if (!SWIG_IsOK(res1)) {
41163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41164 }
41165 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41166 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41167 if (!SWIG_IsOK(ecode2)) {
41168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41169 }
41170 arg2 = static_cast< size_t >(val2);
41171 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41172 if (!SWIG_IsOK(res3)) {
41173 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41174 }
41175 arg3 = reinterpret_cast< wxMenu * >(argp3);
41176 {
41177 arg4 = wxString_in_helper(obj3);
41178 if (arg4 == NULL) SWIG_fail;
41179 temp4 = true;
41180 }
41181 {
41182 PyThreadState* __tstate = wxPyBeginAllowThreads();
41183 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41184 wxPyEndAllowThreads(__tstate);
41185 if (PyErr_Occurred()) SWIG_fail;
41186 }
41187 {
41188 resultobj = wxPyMake_wxObject(result, 0);
41189 }
41190 {
41191 if (temp4)
41192 delete arg4;
41193 }
41194 return resultobj;
41195 fail:
41196 {
41197 if (temp4)
41198 delete arg4;
41199 }
41200 return NULL;
41201 }
41202
41203
41204 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41205 PyObject *resultobj = 0;
41206 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41207 size_t arg2 ;
41208 wxMenu *result = 0 ;
41209 void *argp1 = 0 ;
41210 int res1 = 0 ;
41211 size_t val2 ;
41212 int ecode2 = 0 ;
41213 PyObject * obj0 = 0 ;
41214 PyObject * obj1 = 0 ;
41215 char * kwnames[] = {
41216 (char *) "self",(char *) "pos", NULL
41217 };
41218
41219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41221 if (!SWIG_IsOK(res1)) {
41222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41223 }
41224 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41225 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41226 if (!SWIG_IsOK(ecode2)) {
41227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41228 }
41229 arg2 = static_cast< size_t >(val2);
41230 {
41231 PyThreadState* __tstate = wxPyBeginAllowThreads();
41232 result = (wxMenu *)(arg1)->Remove(arg2);
41233 wxPyEndAllowThreads(__tstate);
41234 if (PyErr_Occurred()) SWIG_fail;
41235 }
41236 {
41237 resultobj = wxPyMake_wxObject(result, 0);
41238 }
41239 return resultobj;
41240 fail:
41241 return NULL;
41242 }
41243
41244
41245 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41246 PyObject *resultobj = 0;
41247 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41248 size_t arg2 ;
41249 bool arg3 ;
41250 void *argp1 = 0 ;
41251 int res1 = 0 ;
41252 size_t val2 ;
41253 int ecode2 = 0 ;
41254 bool val3 ;
41255 int ecode3 = 0 ;
41256 PyObject * obj0 = 0 ;
41257 PyObject * obj1 = 0 ;
41258 PyObject * obj2 = 0 ;
41259 char * kwnames[] = {
41260 (char *) "self",(char *) "pos",(char *) "enable", NULL
41261 };
41262
41263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41265 if (!SWIG_IsOK(res1)) {
41266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41267 }
41268 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41269 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41270 if (!SWIG_IsOK(ecode2)) {
41271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41272 }
41273 arg2 = static_cast< size_t >(val2);
41274 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41275 if (!SWIG_IsOK(ecode3)) {
41276 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41277 }
41278 arg3 = static_cast< bool >(val3);
41279 {
41280 PyThreadState* __tstate = wxPyBeginAllowThreads();
41281 (arg1)->EnableTop(arg2,arg3);
41282 wxPyEndAllowThreads(__tstate);
41283 if (PyErr_Occurred()) SWIG_fail;
41284 }
41285 resultobj = SWIG_Py_Void();
41286 return resultobj;
41287 fail:
41288 return NULL;
41289 }
41290
41291
41292 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41293 PyObject *resultobj = 0;
41294 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41295 size_t arg2 ;
41296 bool result;
41297 void *argp1 = 0 ;
41298 int res1 = 0 ;
41299 size_t val2 ;
41300 int ecode2 = 0 ;
41301 PyObject * obj0 = 0 ;
41302 PyObject * obj1 = 0 ;
41303 char * kwnames[] = {
41304 (char *) "self",(char *) "pos", NULL
41305 };
41306
41307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41309 if (!SWIG_IsOK(res1)) {
41310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41311 }
41312 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41313 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41314 if (!SWIG_IsOK(ecode2)) {
41315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41316 }
41317 arg2 = static_cast< size_t >(val2);
41318 {
41319 PyThreadState* __tstate = wxPyBeginAllowThreads();
41320 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41321 wxPyEndAllowThreads(__tstate);
41322 if (PyErr_Occurred()) SWIG_fail;
41323 }
41324 {
41325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41326 }
41327 return resultobj;
41328 fail:
41329 return NULL;
41330 }
41331
41332
41333 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41334 PyObject *resultobj = 0;
41335 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41336 size_t arg2 ;
41337 wxString *arg3 = 0 ;
41338 void *argp1 = 0 ;
41339 int res1 = 0 ;
41340 size_t val2 ;
41341 int ecode2 = 0 ;
41342 bool temp3 = false ;
41343 PyObject * obj0 = 0 ;
41344 PyObject * obj1 = 0 ;
41345 PyObject * obj2 = 0 ;
41346 char * kwnames[] = {
41347 (char *) "self",(char *) "pos",(char *) "label", NULL
41348 };
41349
41350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41352 if (!SWIG_IsOK(res1)) {
41353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41354 }
41355 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41356 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41357 if (!SWIG_IsOK(ecode2)) {
41358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41359 }
41360 arg2 = static_cast< size_t >(val2);
41361 {
41362 arg3 = wxString_in_helper(obj2);
41363 if (arg3 == NULL) SWIG_fail;
41364 temp3 = true;
41365 }
41366 {
41367 PyThreadState* __tstate = wxPyBeginAllowThreads();
41368 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41369 wxPyEndAllowThreads(__tstate);
41370 if (PyErr_Occurred()) SWIG_fail;
41371 }
41372 resultobj = SWIG_Py_Void();
41373 {
41374 if (temp3)
41375 delete arg3;
41376 }
41377 return resultobj;
41378 fail:
41379 {
41380 if (temp3)
41381 delete arg3;
41382 }
41383 return NULL;
41384 }
41385
41386
41387 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41388 PyObject *resultobj = 0;
41389 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41390 size_t arg2 ;
41391 wxString result;
41392 void *argp1 = 0 ;
41393 int res1 = 0 ;
41394 size_t val2 ;
41395 int ecode2 = 0 ;
41396 PyObject * obj0 = 0 ;
41397 PyObject * obj1 = 0 ;
41398 char * kwnames[] = {
41399 (char *) "self",(char *) "pos", NULL
41400 };
41401
41402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41404 if (!SWIG_IsOK(res1)) {
41405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41406 }
41407 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41408 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41409 if (!SWIG_IsOK(ecode2)) {
41410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41411 }
41412 arg2 = static_cast< size_t >(val2);
41413 {
41414 PyThreadState* __tstate = wxPyBeginAllowThreads();
41415 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41416 wxPyEndAllowThreads(__tstate);
41417 if (PyErr_Occurred()) SWIG_fail;
41418 }
41419 {
41420 #if wxUSE_UNICODE
41421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41422 #else
41423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41424 #endif
41425 }
41426 return resultobj;
41427 fail:
41428 return NULL;
41429 }
41430
41431
41432 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41433 PyObject *resultobj = 0;
41434 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41435 wxString *arg2 = 0 ;
41436 wxString *arg3 = 0 ;
41437 int result;
41438 void *argp1 = 0 ;
41439 int res1 = 0 ;
41440 bool temp2 = false ;
41441 bool temp3 = false ;
41442 PyObject * obj0 = 0 ;
41443 PyObject * obj1 = 0 ;
41444 PyObject * obj2 = 0 ;
41445 char * kwnames[] = {
41446 (char *) "self",(char *) "menu",(char *) "item", NULL
41447 };
41448
41449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41451 if (!SWIG_IsOK(res1)) {
41452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41453 }
41454 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41455 {
41456 arg2 = wxString_in_helper(obj1);
41457 if (arg2 == NULL) SWIG_fail;
41458 temp2 = true;
41459 }
41460 {
41461 arg3 = wxString_in_helper(obj2);
41462 if (arg3 == NULL) SWIG_fail;
41463 temp3 = true;
41464 }
41465 {
41466 PyThreadState* __tstate = wxPyBeginAllowThreads();
41467 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41468 wxPyEndAllowThreads(__tstate);
41469 if (PyErr_Occurred()) SWIG_fail;
41470 }
41471 resultobj = SWIG_From_int(static_cast< int >(result));
41472 {
41473 if (temp2)
41474 delete arg2;
41475 }
41476 {
41477 if (temp3)
41478 delete arg3;
41479 }
41480 return resultobj;
41481 fail:
41482 {
41483 if (temp2)
41484 delete arg2;
41485 }
41486 {
41487 if (temp3)
41488 delete arg3;
41489 }
41490 return NULL;
41491 }
41492
41493
41494 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41495 PyObject *resultobj = 0;
41496 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41497 int arg2 ;
41498 wxMenuItem *result = 0 ;
41499 void *argp1 = 0 ;
41500 int res1 = 0 ;
41501 int val2 ;
41502 int ecode2 = 0 ;
41503 PyObject * obj0 = 0 ;
41504 PyObject * obj1 = 0 ;
41505 char * kwnames[] = {
41506 (char *) "self",(char *) "id", NULL
41507 };
41508
41509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41511 if (!SWIG_IsOK(res1)) {
41512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41513 }
41514 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41515 ecode2 = SWIG_AsVal_int(obj1, &val2);
41516 if (!SWIG_IsOK(ecode2)) {
41517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41518 }
41519 arg2 = static_cast< int >(val2);
41520 {
41521 PyThreadState* __tstate = wxPyBeginAllowThreads();
41522 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41523 wxPyEndAllowThreads(__tstate);
41524 if (PyErr_Occurred()) SWIG_fail;
41525 }
41526 {
41527 resultobj = wxPyMake_wxObject(result, (bool)0);
41528 }
41529 return resultobj;
41530 fail:
41531 return NULL;
41532 }
41533
41534
41535 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41536 PyObject *resultobj = 0;
41537 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41538 wxString *arg2 = 0 ;
41539 int result;
41540 void *argp1 = 0 ;
41541 int res1 = 0 ;
41542 bool temp2 = false ;
41543 PyObject * obj0 = 0 ;
41544 PyObject * obj1 = 0 ;
41545 char * kwnames[] = {
41546 (char *) "self",(char *) "title", NULL
41547 };
41548
41549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41551 if (!SWIG_IsOK(res1)) {
41552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41553 }
41554 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41555 {
41556 arg2 = wxString_in_helper(obj1);
41557 if (arg2 == NULL) SWIG_fail;
41558 temp2 = true;
41559 }
41560 {
41561 PyThreadState* __tstate = wxPyBeginAllowThreads();
41562 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41563 wxPyEndAllowThreads(__tstate);
41564 if (PyErr_Occurred()) SWIG_fail;
41565 }
41566 resultobj = SWIG_From_int(static_cast< int >(result));
41567 {
41568 if (temp2)
41569 delete arg2;
41570 }
41571 return resultobj;
41572 fail:
41573 {
41574 if (temp2)
41575 delete arg2;
41576 }
41577 return NULL;
41578 }
41579
41580
41581 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41582 PyObject *resultobj = 0;
41583 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41584 int arg2 ;
41585 bool arg3 ;
41586 void *argp1 = 0 ;
41587 int res1 = 0 ;
41588 int val2 ;
41589 int ecode2 = 0 ;
41590 bool val3 ;
41591 int ecode3 = 0 ;
41592 PyObject * obj0 = 0 ;
41593 PyObject * obj1 = 0 ;
41594 PyObject * obj2 = 0 ;
41595 char * kwnames[] = {
41596 (char *) "self",(char *) "id",(char *) "enable", NULL
41597 };
41598
41599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41601 if (!SWIG_IsOK(res1)) {
41602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41603 }
41604 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41605 ecode2 = SWIG_AsVal_int(obj1, &val2);
41606 if (!SWIG_IsOK(ecode2)) {
41607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41608 }
41609 arg2 = static_cast< int >(val2);
41610 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41611 if (!SWIG_IsOK(ecode3)) {
41612 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41613 }
41614 arg3 = static_cast< bool >(val3);
41615 {
41616 PyThreadState* __tstate = wxPyBeginAllowThreads();
41617 (arg1)->Enable(arg2,arg3);
41618 wxPyEndAllowThreads(__tstate);
41619 if (PyErr_Occurred()) SWIG_fail;
41620 }
41621 resultobj = SWIG_Py_Void();
41622 return resultobj;
41623 fail:
41624 return NULL;
41625 }
41626
41627
41628 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41629 PyObject *resultobj = 0;
41630 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41631 int arg2 ;
41632 bool arg3 ;
41633 void *argp1 = 0 ;
41634 int res1 = 0 ;
41635 int val2 ;
41636 int ecode2 = 0 ;
41637 bool val3 ;
41638 int ecode3 = 0 ;
41639 PyObject * obj0 = 0 ;
41640 PyObject * obj1 = 0 ;
41641 PyObject * obj2 = 0 ;
41642 char * kwnames[] = {
41643 (char *) "self",(char *) "id",(char *) "check", NULL
41644 };
41645
41646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41648 if (!SWIG_IsOK(res1)) {
41649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41650 }
41651 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41652 ecode2 = SWIG_AsVal_int(obj1, &val2);
41653 if (!SWIG_IsOK(ecode2)) {
41654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41655 }
41656 arg2 = static_cast< int >(val2);
41657 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41658 if (!SWIG_IsOK(ecode3)) {
41659 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41660 }
41661 arg3 = static_cast< bool >(val3);
41662 {
41663 PyThreadState* __tstate = wxPyBeginAllowThreads();
41664 (arg1)->Check(arg2,arg3);
41665 wxPyEndAllowThreads(__tstate);
41666 if (PyErr_Occurred()) SWIG_fail;
41667 }
41668 resultobj = SWIG_Py_Void();
41669 return resultobj;
41670 fail:
41671 return NULL;
41672 }
41673
41674
41675 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41676 PyObject *resultobj = 0;
41677 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41678 int arg2 ;
41679 bool result;
41680 void *argp1 = 0 ;
41681 int res1 = 0 ;
41682 int val2 ;
41683 int ecode2 = 0 ;
41684 PyObject * obj0 = 0 ;
41685 PyObject * obj1 = 0 ;
41686 char * kwnames[] = {
41687 (char *) "self",(char *) "id", NULL
41688 };
41689
41690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41692 if (!SWIG_IsOK(res1)) {
41693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41694 }
41695 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41696 ecode2 = SWIG_AsVal_int(obj1, &val2);
41697 if (!SWIG_IsOK(ecode2)) {
41698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41699 }
41700 arg2 = static_cast< int >(val2);
41701 {
41702 PyThreadState* __tstate = wxPyBeginAllowThreads();
41703 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41704 wxPyEndAllowThreads(__tstate);
41705 if (PyErr_Occurred()) SWIG_fail;
41706 }
41707 {
41708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41709 }
41710 return resultobj;
41711 fail:
41712 return NULL;
41713 }
41714
41715
41716 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41717 PyObject *resultobj = 0;
41718 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41719 int arg2 ;
41720 bool result;
41721 void *argp1 = 0 ;
41722 int res1 = 0 ;
41723 int val2 ;
41724 int ecode2 = 0 ;
41725 PyObject * obj0 = 0 ;
41726 PyObject * obj1 = 0 ;
41727 char * kwnames[] = {
41728 (char *) "self",(char *) "id", NULL
41729 };
41730
41731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41733 if (!SWIG_IsOK(res1)) {
41734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41735 }
41736 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41737 ecode2 = SWIG_AsVal_int(obj1, &val2);
41738 if (!SWIG_IsOK(ecode2)) {
41739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41740 }
41741 arg2 = static_cast< int >(val2);
41742 {
41743 PyThreadState* __tstate = wxPyBeginAllowThreads();
41744 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41745 wxPyEndAllowThreads(__tstate);
41746 if (PyErr_Occurred()) SWIG_fail;
41747 }
41748 {
41749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41750 }
41751 return resultobj;
41752 fail:
41753 return NULL;
41754 }
41755
41756
41757 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41758 PyObject *resultobj = 0;
41759 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41760 int arg2 ;
41761 wxString *arg3 = 0 ;
41762 void *argp1 = 0 ;
41763 int res1 = 0 ;
41764 int val2 ;
41765 int ecode2 = 0 ;
41766 bool temp3 = false ;
41767 PyObject * obj0 = 0 ;
41768 PyObject * obj1 = 0 ;
41769 PyObject * obj2 = 0 ;
41770 char * kwnames[] = {
41771 (char *) "self",(char *) "id",(char *) "label", NULL
41772 };
41773
41774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41776 if (!SWIG_IsOK(res1)) {
41777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41778 }
41779 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41780 ecode2 = SWIG_AsVal_int(obj1, &val2);
41781 if (!SWIG_IsOK(ecode2)) {
41782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41783 }
41784 arg2 = static_cast< int >(val2);
41785 {
41786 arg3 = wxString_in_helper(obj2);
41787 if (arg3 == NULL) SWIG_fail;
41788 temp3 = true;
41789 }
41790 {
41791 PyThreadState* __tstate = wxPyBeginAllowThreads();
41792 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41793 wxPyEndAllowThreads(__tstate);
41794 if (PyErr_Occurred()) SWIG_fail;
41795 }
41796 resultobj = SWIG_Py_Void();
41797 {
41798 if (temp3)
41799 delete arg3;
41800 }
41801 return resultobj;
41802 fail:
41803 {
41804 if (temp3)
41805 delete arg3;
41806 }
41807 return NULL;
41808 }
41809
41810
41811 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41812 PyObject *resultobj = 0;
41813 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41814 int arg2 ;
41815 wxString result;
41816 void *argp1 = 0 ;
41817 int res1 = 0 ;
41818 int val2 ;
41819 int ecode2 = 0 ;
41820 PyObject * obj0 = 0 ;
41821 PyObject * obj1 = 0 ;
41822 char * kwnames[] = {
41823 (char *) "self",(char *) "id", NULL
41824 };
41825
41826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41828 if (!SWIG_IsOK(res1)) {
41829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41830 }
41831 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41832 ecode2 = SWIG_AsVal_int(obj1, &val2);
41833 if (!SWIG_IsOK(ecode2)) {
41834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41835 }
41836 arg2 = static_cast< int >(val2);
41837 {
41838 PyThreadState* __tstate = wxPyBeginAllowThreads();
41839 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41840 wxPyEndAllowThreads(__tstate);
41841 if (PyErr_Occurred()) SWIG_fail;
41842 }
41843 {
41844 #if wxUSE_UNICODE
41845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41846 #else
41847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41848 #endif
41849 }
41850 return resultobj;
41851 fail:
41852 return NULL;
41853 }
41854
41855
41856 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41857 PyObject *resultobj = 0;
41858 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41859 int arg2 ;
41860 wxString *arg3 = 0 ;
41861 void *argp1 = 0 ;
41862 int res1 = 0 ;
41863 int val2 ;
41864 int ecode2 = 0 ;
41865 bool temp3 = false ;
41866 PyObject * obj0 = 0 ;
41867 PyObject * obj1 = 0 ;
41868 PyObject * obj2 = 0 ;
41869 char * kwnames[] = {
41870 (char *) "self",(char *) "id",(char *) "helpString", NULL
41871 };
41872
41873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41875 if (!SWIG_IsOK(res1)) {
41876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41877 }
41878 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41879 ecode2 = SWIG_AsVal_int(obj1, &val2);
41880 if (!SWIG_IsOK(ecode2)) {
41881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41882 }
41883 arg2 = static_cast< int >(val2);
41884 {
41885 arg3 = wxString_in_helper(obj2);
41886 if (arg3 == NULL) SWIG_fail;
41887 temp3 = true;
41888 }
41889 {
41890 PyThreadState* __tstate = wxPyBeginAllowThreads();
41891 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41892 wxPyEndAllowThreads(__tstate);
41893 if (PyErr_Occurred()) SWIG_fail;
41894 }
41895 resultobj = SWIG_Py_Void();
41896 {
41897 if (temp3)
41898 delete arg3;
41899 }
41900 return resultobj;
41901 fail:
41902 {
41903 if (temp3)
41904 delete arg3;
41905 }
41906 return NULL;
41907 }
41908
41909
41910 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41911 PyObject *resultobj = 0;
41912 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41913 int arg2 ;
41914 wxString result;
41915 void *argp1 = 0 ;
41916 int res1 = 0 ;
41917 int val2 ;
41918 int ecode2 = 0 ;
41919 PyObject * obj0 = 0 ;
41920 PyObject * obj1 = 0 ;
41921 char * kwnames[] = {
41922 (char *) "self",(char *) "id", NULL
41923 };
41924
41925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41927 if (!SWIG_IsOK(res1)) {
41928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41929 }
41930 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41931 ecode2 = SWIG_AsVal_int(obj1, &val2);
41932 if (!SWIG_IsOK(ecode2)) {
41933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41934 }
41935 arg2 = static_cast< int >(val2);
41936 {
41937 PyThreadState* __tstate = wxPyBeginAllowThreads();
41938 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41939 wxPyEndAllowThreads(__tstate);
41940 if (PyErr_Occurred()) SWIG_fail;
41941 }
41942 {
41943 #if wxUSE_UNICODE
41944 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41945 #else
41946 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41947 #endif
41948 }
41949 return resultobj;
41950 fail:
41951 return NULL;
41952 }
41953
41954
41955 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41956 PyObject *resultobj = 0;
41957 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41958 wxFrame *result = 0 ;
41959 void *argp1 = 0 ;
41960 int res1 = 0 ;
41961 PyObject *swig_obj[1] ;
41962
41963 if (!args) SWIG_fail;
41964 swig_obj[0] = args;
41965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41966 if (!SWIG_IsOK(res1)) {
41967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41968 }
41969 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41970 {
41971 PyThreadState* __tstate = wxPyBeginAllowThreads();
41972 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41973 wxPyEndAllowThreads(__tstate);
41974 if (PyErr_Occurred()) SWIG_fail;
41975 }
41976 {
41977 resultobj = wxPyMake_wxObject(result, (bool)0);
41978 }
41979 return resultobj;
41980 fail:
41981 return NULL;
41982 }
41983
41984
41985 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41986 PyObject *resultobj = 0;
41987 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41988 bool result;
41989 void *argp1 = 0 ;
41990 int res1 = 0 ;
41991 PyObject *swig_obj[1] ;
41992
41993 if (!args) SWIG_fail;
41994 swig_obj[0] = args;
41995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41996 if (!SWIG_IsOK(res1)) {
41997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41998 }
41999 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42000 {
42001 PyThreadState* __tstate = wxPyBeginAllowThreads();
42002 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42003 wxPyEndAllowThreads(__tstate);
42004 if (PyErr_Occurred()) SWIG_fail;
42005 }
42006 {
42007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42008 }
42009 return resultobj;
42010 fail:
42011 return NULL;
42012 }
42013
42014
42015 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42016 PyObject *resultobj = 0;
42017 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42018 wxFrame *arg2 = (wxFrame *) 0 ;
42019 void *argp1 = 0 ;
42020 int res1 = 0 ;
42021 void *argp2 = 0 ;
42022 int res2 = 0 ;
42023 PyObject * obj0 = 0 ;
42024 PyObject * obj1 = 0 ;
42025 char * kwnames[] = {
42026 (char *) "self",(char *) "frame", NULL
42027 };
42028
42029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42031 if (!SWIG_IsOK(res1)) {
42032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42033 }
42034 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42035 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42036 if (!SWIG_IsOK(res2)) {
42037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42038 }
42039 arg2 = reinterpret_cast< wxFrame * >(argp2);
42040 {
42041 PyThreadState* __tstate = wxPyBeginAllowThreads();
42042 (arg1)->Attach(arg2);
42043 wxPyEndAllowThreads(__tstate);
42044 if (PyErr_Occurred()) SWIG_fail;
42045 }
42046 resultobj = SWIG_Py_Void();
42047 return resultobj;
42048 fail:
42049 return NULL;
42050 }
42051
42052
42053 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42054 PyObject *resultobj = 0;
42055 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42056 void *argp1 = 0 ;
42057 int res1 = 0 ;
42058 PyObject *swig_obj[1] ;
42059
42060 if (!args) SWIG_fail;
42061 swig_obj[0] = args;
42062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42063 if (!SWIG_IsOK(res1)) {
42064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42065 }
42066 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42067 {
42068 PyThreadState* __tstate = wxPyBeginAllowThreads();
42069 (arg1)->Detach();
42070 wxPyEndAllowThreads(__tstate);
42071 if (PyErr_Occurred()) SWIG_fail;
42072 }
42073 resultobj = SWIG_Py_Void();
42074 return resultobj;
42075 fail:
42076 return NULL;
42077 }
42078
42079
42080 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42081 PyObject *resultobj = 0;
42082 bool arg1 ;
42083 bool val1 ;
42084 int ecode1 = 0 ;
42085 PyObject * obj0 = 0 ;
42086 char * kwnames[] = {
42087 (char *) "enable", NULL
42088 };
42089
42090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42091 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42092 if (!SWIG_IsOK(ecode1)) {
42093 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42094 }
42095 arg1 = static_cast< bool >(val1);
42096 {
42097 PyThreadState* __tstate = wxPyBeginAllowThreads();
42098 wxMenuBar::SetAutoWindowMenu(arg1);
42099 wxPyEndAllowThreads(__tstate);
42100 if (PyErr_Occurred()) SWIG_fail;
42101 }
42102 resultobj = SWIG_Py_Void();
42103 return resultobj;
42104 fail:
42105 return NULL;
42106 }
42107
42108
42109 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42110 PyObject *resultobj = 0;
42111 bool result;
42112
42113 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42114 {
42115 PyThreadState* __tstate = wxPyBeginAllowThreads();
42116 result = (bool)wxMenuBar::GetAutoWindowMenu();
42117 wxPyEndAllowThreads(__tstate);
42118 if (PyErr_Occurred()) SWIG_fail;
42119 }
42120 {
42121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42122 }
42123 return resultobj;
42124 fail:
42125 return NULL;
42126 }
42127
42128
42129 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42130 PyObject *obj;
42131 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42132 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42133 return SWIG_Py_Void();
42134 }
42135
42136 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42137 return SWIG_Python_InitShadowInstance(args);
42138 }
42139
42140 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42141 PyObject *resultobj = 0;
42142 wxMenu *arg1 = (wxMenu *) NULL ;
42143 int arg2 = (int) wxID_ANY ;
42144 wxString const &arg3_defvalue = wxPyEmptyString ;
42145 wxString *arg3 = (wxString *) &arg3_defvalue ;
42146 wxString const &arg4_defvalue = wxPyEmptyString ;
42147 wxString *arg4 = (wxString *) &arg4_defvalue ;
42148 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42149 wxMenu *arg6 = (wxMenu *) NULL ;
42150 wxMenuItem *result = 0 ;
42151 void *argp1 = 0 ;
42152 int res1 = 0 ;
42153 int val2 ;
42154 int ecode2 = 0 ;
42155 bool temp3 = false ;
42156 bool temp4 = false ;
42157 int val5 ;
42158 int ecode5 = 0 ;
42159 void *argp6 = 0 ;
42160 int res6 = 0 ;
42161 PyObject * obj0 = 0 ;
42162 PyObject * obj1 = 0 ;
42163 PyObject * obj2 = 0 ;
42164 PyObject * obj3 = 0 ;
42165 PyObject * obj4 = 0 ;
42166 PyObject * obj5 = 0 ;
42167 char * kwnames[] = {
42168 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42169 };
42170
42171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42172 if (obj0) {
42173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42174 if (!SWIG_IsOK(res1)) {
42175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42176 }
42177 arg1 = reinterpret_cast< wxMenu * >(argp1);
42178 }
42179 if (obj1) {
42180 ecode2 = SWIG_AsVal_int(obj1, &val2);
42181 if (!SWIG_IsOK(ecode2)) {
42182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42183 }
42184 arg2 = static_cast< int >(val2);
42185 }
42186 if (obj2) {
42187 {
42188 arg3 = wxString_in_helper(obj2);
42189 if (arg3 == NULL) SWIG_fail;
42190 temp3 = true;
42191 }
42192 }
42193 if (obj3) {
42194 {
42195 arg4 = wxString_in_helper(obj3);
42196 if (arg4 == NULL) SWIG_fail;
42197 temp4 = true;
42198 }
42199 }
42200 if (obj4) {
42201 ecode5 = SWIG_AsVal_int(obj4, &val5);
42202 if (!SWIG_IsOK(ecode5)) {
42203 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42204 }
42205 arg5 = static_cast< wxItemKind >(val5);
42206 }
42207 if (obj5) {
42208 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42209 if (!SWIG_IsOK(res6)) {
42210 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42211 }
42212 arg6 = reinterpret_cast< wxMenu * >(argp6);
42213 }
42214 {
42215 PyThreadState* __tstate = wxPyBeginAllowThreads();
42216 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42217 wxPyEndAllowThreads(__tstate);
42218 if (PyErr_Occurred()) SWIG_fail;
42219 }
42220 {
42221 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42222 }
42223 {
42224 if (temp3)
42225 delete arg3;
42226 }
42227 {
42228 if (temp4)
42229 delete arg4;
42230 }
42231 return resultobj;
42232 fail:
42233 {
42234 if (temp3)
42235 delete arg3;
42236 }
42237 {
42238 if (temp4)
42239 delete arg4;
42240 }
42241 return NULL;
42242 }
42243
42244
42245 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42246 PyObject *resultobj = 0;
42247 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42248 void *argp1 = 0 ;
42249 int res1 = 0 ;
42250 PyObject *swig_obj[1] ;
42251
42252 if (!args) SWIG_fail;
42253 swig_obj[0] = args;
42254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42255 if (!SWIG_IsOK(res1)) {
42256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42257 }
42258 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42259 {
42260 PyThreadState* __tstate = wxPyBeginAllowThreads();
42261 delete arg1;
42262
42263 wxPyEndAllowThreads(__tstate);
42264 if (PyErr_Occurred()) SWIG_fail;
42265 }
42266 resultobj = SWIG_Py_Void();
42267 return resultobj;
42268 fail:
42269 return NULL;
42270 }
42271
42272
42273 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42274 PyObject *resultobj = 0;
42275 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42276 wxMenu *result = 0 ;
42277 void *argp1 = 0 ;
42278 int res1 = 0 ;
42279 PyObject *swig_obj[1] ;
42280
42281 if (!args) SWIG_fail;
42282 swig_obj[0] = args;
42283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42284 if (!SWIG_IsOK(res1)) {
42285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42286 }
42287 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42288 {
42289 PyThreadState* __tstate = wxPyBeginAllowThreads();
42290 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42291 wxPyEndAllowThreads(__tstate);
42292 if (PyErr_Occurred()) SWIG_fail;
42293 }
42294 {
42295 resultobj = wxPyMake_wxObject(result, 0);
42296 }
42297 return resultobj;
42298 fail:
42299 return NULL;
42300 }
42301
42302
42303 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42304 PyObject *resultobj = 0;
42305 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42306 wxMenu *arg2 = (wxMenu *) 0 ;
42307 void *argp1 = 0 ;
42308 int res1 = 0 ;
42309 void *argp2 = 0 ;
42310 int res2 = 0 ;
42311 PyObject * obj0 = 0 ;
42312 PyObject * obj1 = 0 ;
42313 char * kwnames[] = {
42314 (char *) "self",(char *) "menu", NULL
42315 };
42316
42317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42319 if (!SWIG_IsOK(res1)) {
42320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42321 }
42322 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42323 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42324 if (!SWIG_IsOK(res2)) {
42325 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42326 }
42327 arg2 = reinterpret_cast< wxMenu * >(argp2);
42328 {
42329 PyThreadState* __tstate = wxPyBeginAllowThreads();
42330 (arg1)->SetMenu(arg2);
42331 wxPyEndAllowThreads(__tstate);
42332 if (PyErr_Occurred()) SWIG_fail;
42333 }
42334 resultobj = SWIG_Py_Void();
42335 return resultobj;
42336 fail:
42337 return NULL;
42338 }
42339
42340
42341 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42342 PyObject *resultobj = 0;
42343 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42344 int arg2 ;
42345 void *argp1 = 0 ;
42346 int res1 = 0 ;
42347 int val2 ;
42348 int ecode2 = 0 ;
42349 PyObject * obj0 = 0 ;
42350 PyObject * obj1 = 0 ;
42351 char * kwnames[] = {
42352 (char *) "self",(char *) "id", NULL
42353 };
42354
42355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42357 if (!SWIG_IsOK(res1)) {
42358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42359 }
42360 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42361 ecode2 = SWIG_AsVal_int(obj1, &val2);
42362 if (!SWIG_IsOK(ecode2)) {
42363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42364 }
42365 arg2 = static_cast< int >(val2);
42366 {
42367 PyThreadState* __tstate = wxPyBeginAllowThreads();
42368 (arg1)->SetId(arg2);
42369 wxPyEndAllowThreads(__tstate);
42370 if (PyErr_Occurred()) SWIG_fail;
42371 }
42372 resultobj = SWIG_Py_Void();
42373 return resultobj;
42374 fail:
42375 return NULL;
42376 }
42377
42378
42379 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42380 PyObject *resultobj = 0;
42381 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42382 int result;
42383 void *argp1 = 0 ;
42384 int res1 = 0 ;
42385 PyObject *swig_obj[1] ;
42386
42387 if (!args) SWIG_fail;
42388 swig_obj[0] = args;
42389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42390 if (!SWIG_IsOK(res1)) {
42391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42392 }
42393 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42394 {
42395 PyThreadState* __tstate = wxPyBeginAllowThreads();
42396 result = (int)((wxMenuItem const *)arg1)->GetId();
42397 wxPyEndAllowThreads(__tstate);
42398 if (PyErr_Occurred()) SWIG_fail;
42399 }
42400 resultobj = SWIG_From_int(static_cast< int >(result));
42401 return resultobj;
42402 fail:
42403 return NULL;
42404 }
42405
42406
42407 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42408 PyObject *resultobj = 0;
42409 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42410 bool result;
42411 void *argp1 = 0 ;
42412 int res1 = 0 ;
42413 PyObject *swig_obj[1] ;
42414
42415 if (!args) SWIG_fail;
42416 swig_obj[0] = args;
42417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42418 if (!SWIG_IsOK(res1)) {
42419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42420 }
42421 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42422 {
42423 PyThreadState* __tstate = wxPyBeginAllowThreads();
42424 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42425 wxPyEndAllowThreads(__tstate);
42426 if (PyErr_Occurred()) SWIG_fail;
42427 }
42428 {
42429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42430 }
42431 return resultobj;
42432 fail:
42433 return NULL;
42434 }
42435
42436
42437 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42438 PyObject *resultobj = 0;
42439 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42440 wxString *arg2 = 0 ;
42441 void *argp1 = 0 ;
42442 int res1 = 0 ;
42443 bool temp2 = false ;
42444 PyObject * obj0 = 0 ;
42445 PyObject * obj1 = 0 ;
42446 char * kwnames[] = {
42447 (char *) "self",(char *) "str", NULL
42448 };
42449
42450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42452 if (!SWIG_IsOK(res1)) {
42453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42454 }
42455 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42456 {
42457 arg2 = wxString_in_helper(obj1);
42458 if (arg2 == NULL) SWIG_fail;
42459 temp2 = true;
42460 }
42461 {
42462 PyThreadState* __tstate = wxPyBeginAllowThreads();
42463 (arg1)->SetText((wxString const &)*arg2);
42464 wxPyEndAllowThreads(__tstate);
42465 if (PyErr_Occurred()) SWIG_fail;
42466 }
42467 resultobj = SWIG_Py_Void();
42468 {
42469 if (temp2)
42470 delete arg2;
42471 }
42472 return resultobj;
42473 fail:
42474 {
42475 if (temp2)
42476 delete arg2;
42477 }
42478 return NULL;
42479 }
42480
42481
42482 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42483 PyObject *resultobj = 0;
42484 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42485 wxString result;
42486 void *argp1 = 0 ;
42487 int res1 = 0 ;
42488 PyObject *swig_obj[1] ;
42489
42490 if (!args) SWIG_fail;
42491 swig_obj[0] = args;
42492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42493 if (!SWIG_IsOK(res1)) {
42494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42495 }
42496 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42497 {
42498 PyThreadState* __tstate = wxPyBeginAllowThreads();
42499 result = ((wxMenuItem const *)arg1)->GetLabel();
42500 wxPyEndAllowThreads(__tstate);
42501 if (PyErr_Occurred()) SWIG_fail;
42502 }
42503 {
42504 #if wxUSE_UNICODE
42505 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42506 #else
42507 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42508 #endif
42509 }
42510 return resultobj;
42511 fail:
42512 return NULL;
42513 }
42514
42515
42516 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42517 PyObject *resultobj = 0;
42518 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42519 wxString *result = 0 ;
42520 void *argp1 = 0 ;
42521 int res1 = 0 ;
42522 PyObject *swig_obj[1] ;
42523
42524 if (!args) SWIG_fail;
42525 swig_obj[0] = args;
42526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42527 if (!SWIG_IsOK(res1)) {
42528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42529 }
42530 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42531 {
42532 PyThreadState* __tstate = wxPyBeginAllowThreads();
42533 {
42534 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42535 result = (wxString *) &_result_ref;
42536 }
42537 wxPyEndAllowThreads(__tstate);
42538 if (PyErr_Occurred()) SWIG_fail;
42539 }
42540 {
42541 #if wxUSE_UNICODE
42542 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42543 #else
42544 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42545 #endif
42546 }
42547 return resultobj;
42548 fail:
42549 return NULL;
42550 }
42551
42552
42553 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42554 PyObject *resultobj = 0;
42555 wxString *arg1 = 0 ;
42556 wxString result;
42557 bool temp1 = false ;
42558 PyObject * obj0 = 0 ;
42559 char * kwnames[] = {
42560 (char *) "text", NULL
42561 };
42562
42563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42564 {
42565 arg1 = wxString_in_helper(obj0);
42566 if (arg1 == NULL) SWIG_fail;
42567 temp1 = true;
42568 }
42569 {
42570 PyThreadState* __tstate = wxPyBeginAllowThreads();
42571 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42572 wxPyEndAllowThreads(__tstate);
42573 if (PyErr_Occurred()) SWIG_fail;
42574 }
42575 {
42576 #if wxUSE_UNICODE
42577 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42578 #else
42579 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42580 #endif
42581 }
42582 {
42583 if (temp1)
42584 delete arg1;
42585 }
42586 return resultobj;
42587 fail:
42588 {
42589 if (temp1)
42590 delete arg1;
42591 }
42592 return NULL;
42593 }
42594
42595
42596 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42597 PyObject *resultobj = 0;
42598 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42599 wxItemKind result;
42600 void *argp1 = 0 ;
42601 int res1 = 0 ;
42602 PyObject *swig_obj[1] ;
42603
42604 if (!args) SWIG_fail;
42605 swig_obj[0] = args;
42606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42607 if (!SWIG_IsOK(res1)) {
42608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42609 }
42610 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42611 {
42612 PyThreadState* __tstate = wxPyBeginAllowThreads();
42613 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42614 wxPyEndAllowThreads(__tstate);
42615 if (PyErr_Occurred()) SWIG_fail;
42616 }
42617 resultobj = SWIG_From_int(static_cast< int >(result));
42618 return resultobj;
42619 fail:
42620 return NULL;
42621 }
42622
42623
42624 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42625 PyObject *resultobj = 0;
42626 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42627 wxItemKind arg2 ;
42628 void *argp1 = 0 ;
42629 int res1 = 0 ;
42630 int val2 ;
42631 int ecode2 = 0 ;
42632 PyObject * obj0 = 0 ;
42633 PyObject * obj1 = 0 ;
42634 char * kwnames[] = {
42635 (char *) "self",(char *) "kind", NULL
42636 };
42637
42638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42640 if (!SWIG_IsOK(res1)) {
42641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42642 }
42643 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42644 ecode2 = SWIG_AsVal_int(obj1, &val2);
42645 if (!SWIG_IsOK(ecode2)) {
42646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42647 }
42648 arg2 = static_cast< wxItemKind >(val2);
42649 {
42650 PyThreadState* __tstate = wxPyBeginAllowThreads();
42651 (arg1)->SetKind(arg2);
42652 wxPyEndAllowThreads(__tstate);
42653 if (PyErr_Occurred()) SWIG_fail;
42654 }
42655 resultobj = SWIG_Py_Void();
42656 return resultobj;
42657 fail:
42658 return NULL;
42659 }
42660
42661
42662 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42663 PyObject *resultobj = 0;
42664 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42665 bool arg2 ;
42666 void *argp1 = 0 ;
42667 int res1 = 0 ;
42668 bool val2 ;
42669 int ecode2 = 0 ;
42670 PyObject * obj0 = 0 ;
42671 PyObject * obj1 = 0 ;
42672 char * kwnames[] = {
42673 (char *) "self",(char *) "checkable", NULL
42674 };
42675
42676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42678 if (!SWIG_IsOK(res1)) {
42679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42680 }
42681 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42682 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42683 if (!SWIG_IsOK(ecode2)) {
42684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42685 }
42686 arg2 = static_cast< bool >(val2);
42687 {
42688 PyThreadState* __tstate = wxPyBeginAllowThreads();
42689 (arg1)->SetCheckable(arg2);
42690 wxPyEndAllowThreads(__tstate);
42691 if (PyErr_Occurred()) SWIG_fail;
42692 }
42693 resultobj = SWIG_Py_Void();
42694 return resultobj;
42695 fail:
42696 return NULL;
42697 }
42698
42699
42700 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42701 PyObject *resultobj = 0;
42702 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42703 bool result;
42704 void *argp1 = 0 ;
42705 int res1 = 0 ;
42706 PyObject *swig_obj[1] ;
42707
42708 if (!args) SWIG_fail;
42709 swig_obj[0] = args;
42710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42711 if (!SWIG_IsOK(res1)) {
42712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42713 }
42714 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42715 {
42716 PyThreadState* __tstate = wxPyBeginAllowThreads();
42717 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42718 wxPyEndAllowThreads(__tstate);
42719 if (PyErr_Occurred()) SWIG_fail;
42720 }
42721 {
42722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42723 }
42724 return resultobj;
42725 fail:
42726 return NULL;
42727 }
42728
42729
42730 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42731 PyObject *resultobj = 0;
42732 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42733 bool result;
42734 void *argp1 = 0 ;
42735 int res1 = 0 ;
42736 PyObject *swig_obj[1] ;
42737
42738 if (!args) SWIG_fail;
42739 swig_obj[0] = args;
42740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42741 if (!SWIG_IsOK(res1)) {
42742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42743 }
42744 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42745 {
42746 PyThreadState* __tstate = wxPyBeginAllowThreads();
42747 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42748 wxPyEndAllowThreads(__tstate);
42749 if (PyErr_Occurred()) SWIG_fail;
42750 }
42751 {
42752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42753 }
42754 return resultobj;
42755 fail:
42756 return NULL;
42757 }
42758
42759
42760 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42761 PyObject *resultobj = 0;
42762 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42763 wxMenu *arg2 = (wxMenu *) 0 ;
42764 void *argp1 = 0 ;
42765 int res1 = 0 ;
42766 void *argp2 = 0 ;
42767 int res2 = 0 ;
42768 PyObject * obj0 = 0 ;
42769 PyObject * obj1 = 0 ;
42770 char * kwnames[] = {
42771 (char *) "self",(char *) "menu", NULL
42772 };
42773
42774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42776 if (!SWIG_IsOK(res1)) {
42777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42778 }
42779 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42780 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42781 if (!SWIG_IsOK(res2)) {
42782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42783 }
42784 arg2 = reinterpret_cast< wxMenu * >(argp2);
42785 {
42786 PyThreadState* __tstate = wxPyBeginAllowThreads();
42787 (arg1)->SetSubMenu(arg2);
42788 wxPyEndAllowThreads(__tstate);
42789 if (PyErr_Occurred()) SWIG_fail;
42790 }
42791 resultobj = SWIG_Py_Void();
42792 return resultobj;
42793 fail:
42794 return NULL;
42795 }
42796
42797
42798 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42799 PyObject *resultobj = 0;
42800 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42801 wxMenu *result = 0 ;
42802 void *argp1 = 0 ;
42803 int res1 = 0 ;
42804 PyObject *swig_obj[1] ;
42805
42806 if (!args) SWIG_fail;
42807 swig_obj[0] = args;
42808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42809 if (!SWIG_IsOK(res1)) {
42810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42811 }
42812 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42813 {
42814 PyThreadState* __tstate = wxPyBeginAllowThreads();
42815 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42816 wxPyEndAllowThreads(__tstate);
42817 if (PyErr_Occurred()) SWIG_fail;
42818 }
42819 {
42820 resultobj = wxPyMake_wxObject(result, 0);
42821 }
42822 return resultobj;
42823 fail:
42824 return NULL;
42825 }
42826
42827
42828 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42829 PyObject *resultobj = 0;
42830 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42831 bool arg2 = (bool) true ;
42832 void *argp1 = 0 ;
42833 int res1 = 0 ;
42834 bool val2 ;
42835 int ecode2 = 0 ;
42836 PyObject * obj0 = 0 ;
42837 PyObject * obj1 = 0 ;
42838 char * kwnames[] = {
42839 (char *) "self",(char *) "enable", NULL
42840 };
42841
42842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42844 if (!SWIG_IsOK(res1)) {
42845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42846 }
42847 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42848 if (obj1) {
42849 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42850 if (!SWIG_IsOK(ecode2)) {
42851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42852 }
42853 arg2 = static_cast< bool >(val2);
42854 }
42855 {
42856 PyThreadState* __tstate = wxPyBeginAllowThreads();
42857 (arg1)->Enable(arg2);
42858 wxPyEndAllowThreads(__tstate);
42859 if (PyErr_Occurred()) SWIG_fail;
42860 }
42861 resultobj = SWIG_Py_Void();
42862 return resultobj;
42863 fail:
42864 return NULL;
42865 }
42866
42867
42868 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42869 PyObject *resultobj = 0;
42870 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42871 bool result;
42872 void *argp1 = 0 ;
42873 int res1 = 0 ;
42874 PyObject *swig_obj[1] ;
42875
42876 if (!args) SWIG_fail;
42877 swig_obj[0] = args;
42878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42879 if (!SWIG_IsOK(res1)) {
42880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42881 }
42882 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42883 {
42884 PyThreadState* __tstate = wxPyBeginAllowThreads();
42885 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42886 wxPyEndAllowThreads(__tstate);
42887 if (PyErr_Occurred()) SWIG_fail;
42888 }
42889 {
42890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42891 }
42892 return resultobj;
42893 fail:
42894 return NULL;
42895 }
42896
42897
42898 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42899 PyObject *resultobj = 0;
42900 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42901 bool arg2 = (bool) true ;
42902 void *argp1 = 0 ;
42903 int res1 = 0 ;
42904 bool val2 ;
42905 int ecode2 = 0 ;
42906 PyObject * obj0 = 0 ;
42907 PyObject * obj1 = 0 ;
42908 char * kwnames[] = {
42909 (char *) "self",(char *) "check", NULL
42910 };
42911
42912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42914 if (!SWIG_IsOK(res1)) {
42915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42916 }
42917 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42918 if (obj1) {
42919 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42920 if (!SWIG_IsOK(ecode2)) {
42921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42922 }
42923 arg2 = static_cast< bool >(val2);
42924 }
42925 {
42926 PyThreadState* __tstate = wxPyBeginAllowThreads();
42927 (arg1)->Check(arg2);
42928 wxPyEndAllowThreads(__tstate);
42929 if (PyErr_Occurred()) SWIG_fail;
42930 }
42931 resultobj = SWIG_Py_Void();
42932 return resultobj;
42933 fail:
42934 return NULL;
42935 }
42936
42937
42938 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42939 PyObject *resultobj = 0;
42940 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42941 bool result;
42942 void *argp1 = 0 ;
42943 int res1 = 0 ;
42944 PyObject *swig_obj[1] ;
42945
42946 if (!args) SWIG_fail;
42947 swig_obj[0] = args;
42948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42949 if (!SWIG_IsOK(res1)) {
42950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42951 }
42952 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42953 {
42954 PyThreadState* __tstate = wxPyBeginAllowThreads();
42955 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42956 wxPyEndAllowThreads(__tstate);
42957 if (PyErr_Occurred()) SWIG_fail;
42958 }
42959 {
42960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42961 }
42962 return resultobj;
42963 fail:
42964 return NULL;
42965 }
42966
42967
42968 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42969 PyObject *resultobj = 0;
42970 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42971 void *argp1 = 0 ;
42972 int res1 = 0 ;
42973 PyObject *swig_obj[1] ;
42974
42975 if (!args) SWIG_fail;
42976 swig_obj[0] = args;
42977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42978 if (!SWIG_IsOK(res1)) {
42979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42980 }
42981 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42982 {
42983 PyThreadState* __tstate = wxPyBeginAllowThreads();
42984 (arg1)->Toggle();
42985 wxPyEndAllowThreads(__tstate);
42986 if (PyErr_Occurred()) SWIG_fail;
42987 }
42988 resultobj = SWIG_Py_Void();
42989 return resultobj;
42990 fail:
42991 return NULL;
42992 }
42993
42994
42995 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42996 PyObject *resultobj = 0;
42997 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42998 wxString *arg2 = 0 ;
42999 void *argp1 = 0 ;
43000 int res1 = 0 ;
43001 bool temp2 = false ;
43002 PyObject * obj0 = 0 ;
43003 PyObject * obj1 = 0 ;
43004 char * kwnames[] = {
43005 (char *) "self",(char *) "str", NULL
43006 };
43007
43008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43010 if (!SWIG_IsOK(res1)) {
43011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43012 }
43013 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43014 {
43015 arg2 = wxString_in_helper(obj1);
43016 if (arg2 == NULL) SWIG_fail;
43017 temp2 = true;
43018 }
43019 {
43020 PyThreadState* __tstate = wxPyBeginAllowThreads();
43021 (arg1)->SetHelp((wxString const &)*arg2);
43022 wxPyEndAllowThreads(__tstate);
43023 if (PyErr_Occurred()) SWIG_fail;
43024 }
43025 resultobj = SWIG_Py_Void();
43026 {
43027 if (temp2)
43028 delete arg2;
43029 }
43030 return resultobj;
43031 fail:
43032 {
43033 if (temp2)
43034 delete arg2;
43035 }
43036 return NULL;
43037 }
43038
43039
43040 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43041 PyObject *resultobj = 0;
43042 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43043 wxString *result = 0 ;
43044 void *argp1 = 0 ;
43045 int res1 = 0 ;
43046 PyObject *swig_obj[1] ;
43047
43048 if (!args) SWIG_fail;
43049 swig_obj[0] = args;
43050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43051 if (!SWIG_IsOK(res1)) {
43052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43053 }
43054 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43055 {
43056 PyThreadState* __tstate = wxPyBeginAllowThreads();
43057 {
43058 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43059 result = (wxString *) &_result_ref;
43060 }
43061 wxPyEndAllowThreads(__tstate);
43062 if (PyErr_Occurred()) SWIG_fail;
43063 }
43064 {
43065 #if wxUSE_UNICODE
43066 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43067 #else
43068 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43069 #endif
43070 }
43071 return resultobj;
43072 fail:
43073 return NULL;
43074 }
43075
43076
43077 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43078 PyObject *resultobj = 0;
43079 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43080 wxAcceleratorEntry *result = 0 ;
43081 void *argp1 = 0 ;
43082 int res1 = 0 ;
43083 PyObject *swig_obj[1] ;
43084
43085 if (!args) SWIG_fail;
43086 swig_obj[0] = args;
43087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43088 if (!SWIG_IsOK(res1)) {
43089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43090 }
43091 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43092 {
43093 PyThreadState* __tstate = wxPyBeginAllowThreads();
43094 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43095 wxPyEndAllowThreads(__tstate);
43096 if (PyErr_Occurred()) SWIG_fail;
43097 }
43098 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43099 return resultobj;
43100 fail:
43101 return NULL;
43102 }
43103
43104
43105 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43106 PyObject *resultobj = 0;
43107 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43108 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43109 void *argp1 = 0 ;
43110 int res1 = 0 ;
43111 void *argp2 = 0 ;
43112 int res2 = 0 ;
43113 PyObject * obj0 = 0 ;
43114 PyObject * obj1 = 0 ;
43115 char * kwnames[] = {
43116 (char *) "self",(char *) "accel", NULL
43117 };
43118
43119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43121 if (!SWIG_IsOK(res1)) {
43122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43123 }
43124 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43125 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43126 if (!SWIG_IsOK(res2)) {
43127 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43128 }
43129 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43130 {
43131 PyThreadState* __tstate = wxPyBeginAllowThreads();
43132 (arg1)->SetAccel(arg2);
43133 wxPyEndAllowThreads(__tstate);
43134 if (PyErr_Occurred()) SWIG_fail;
43135 }
43136 resultobj = SWIG_Py_Void();
43137 return resultobj;
43138 fail:
43139 return NULL;
43140 }
43141
43142
43143 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43144 PyObject *resultobj = 0;
43145 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43146 wxBitmap *arg2 = 0 ;
43147 void *argp1 = 0 ;
43148 int res1 = 0 ;
43149 void *argp2 = 0 ;
43150 int res2 = 0 ;
43151 PyObject * obj0 = 0 ;
43152 PyObject * obj1 = 0 ;
43153 char * kwnames[] = {
43154 (char *) "self",(char *) "bitmap", NULL
43155 };
43156
43157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43159 if (!SWIG_IsOK(res1)) {
43160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43161 }
43162 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43163 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43164 if (!SWIG_IsOK(res2)) {
43165 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43166 }
43167 if (!argp2) {
43168 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43169 }
43170 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43171 {
43172 PyThreadState* __tstate = wxPyBeginAllowThreads();
43173 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43174 wxPyEndAllowThreads(__tstate);
43175 if (PyErr_Occurred()) SWIG_fail;
43176 }
43177 resultobj = SWIG_Py_Void();
43178 return resultobj;
43179 fail:
43180 return NULL;
43181 }
43182
43183
43184 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43185 PyObject *resultobj = 0;
43186 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43187 wxBitmap *result = 0 ;
43188 void *argp1 = 0 ;
43189 int res1 = 0 ;
43190 PyObject *swig_obj[1] ;
43191
43192 if (!args) SWIG_fail;
43193 swig_obj[0] = args;
43194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43195 if (!SWIG_IsOK(res1)) {
43196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43197 }
43198 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43199 {
43200 PyThreadState* __tstate = wxPyBeginAllowThreads();
43201 {
43202 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43203 result = (wxBitmap *) &_result_ref;
43204 }
43205 wxPyEndAllowThreads(__tstate);
43206 if (PyErr_Occurred()) SWIG_fail;
43207 }
43208 {
43209 wxBitmap* resultptr = new wxBitmap(*result);
43210 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43211 }
43212 return resultobj;
43213 fail:
43214 return NULL;
43215 }
43216
43217
43218 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43219 PyObject *resultobj = 0;
43220 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43221 wxFont *arg2 = 0 ;
43222 void *argp1 = 0 ;
43223 int res1 = 0 ;
43224 void *argp2 = 0 ;
43225 int res2 = 0 ;
43226 PyObject * obj0 = 0 ;
43227 PyObject * obj1 = 0 ;
43228 char * kwnames[] = {
43229 (char *) "self",(char *) "font", NULL
43230 };
43231
43232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43234 if (!SWIG_IsOK(res1)) {
43235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43236 }
43237 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43238 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43239 if (!SWIG_IsOK(res2)) {
43240 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43241 }
43242 if (!argp2) {
43243 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43244 }
43245 arg2 = reinterpret_cast< wxFont * >(argp2);
43246 {
43247 PyThreadState* __tstate = wxPyBeginAllowThreads();
43248 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43249 wxPyEndAllowThreads(__tstate);
43250 if (PyErr_Occurred()) SWIG_fail;
43251 }
43252 resultobj = SWIG_Py_Void();
43253 return resultobj;
43254 fail:
43255 return NULL;
43256 }
43257
43258
43259 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43260 PyObject *resultobj = 0;
43261 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43262 wxFont result;
43263 void *argp1 = 0 ;
43264 int res1 = 0 ;
43265 PyObject *swig_obj[1] ;
43266
43267 if (!args) SWIG_fail;
43268 swig_obj[0] = args;
43269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43270 if (!SWIG_IsOK(res1)) {
43271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43272 }
43273 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43274 {
43275 PyThreadState* __tstate = wxPyBeginAllowThreads();
43276 result = wxMenuItem_GetFont(arg1);
43277 wxPyEndAllowThreads(__tstate);
43278 if (PyErr_Occurred()) SWIG_fail;
43279 }
43280 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43281 return resultobj;
43282 fail:
43283 return NULL;
43284 }
43285
43286
43287 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43288 PyObject *resultobj = 0;
43289 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43290 wxColour *arg2 = 0 ;
43291 void *argp1 = 0 ;
43292 int res1 = 0 ;
43293 wxColour temp2 ;
43294 PyObject * obj0 = 0 ;
43295 PyObject * obj1 = 0 ;
43296 char * kwnames[] = {
43297 (char *) "self",(char *) "colText", NULL
43298 };
43299
43300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43302 if (!SWIG_IsOK(res1)) {
43303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43304 }
43305 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43306 {
43307 arg2 = &temp2;
43308 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43309 }
43310 {
43311 PyThreadState* __tstate = wxPyBeginAllowThreads();
43312 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43313 wxPyEndAllowThreads(__tstate);
43314 if (PyErr_Occurred()) SWIG_fail;
43315 }
43316 resultobj = SWIG_Py_Void();
43317 return resultobj;
43318 fail:
43319 return NULL;
43320 }
43321
43322
43323 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43324 PyObject *resultobj = 0;
43325 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43326 wxColour result;
43327 void *argp1 = 0 ;
43328 int res1 = 0 ;
43329 PyObject *swig_obj[1] ;
43330
43331 if (!args) SWIG_fail;
43332 swig_obj[0] = args;
43333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43334 if (!SWIG_IsOK(res1)) {
43335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43336 }
43337 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43338 {
43339 PyThreadState* __tstate = wxPyBeginAllowThreads();
43340 result = wxMenuItem_GetTextColour(arg1);
43341 wxPyEndAllowThreads(__tstate);
43342 if (PyErr_Occurred()) SWIG_fail;
43343 }
43344 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43345 return resultobj;
43346 fail:
43347 return NULL;
43348 }
43349
43350
43351 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43352 PyObject *resultobj = 0;
43353 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43354 wxColour *arg2 = 0 ;
43355 void *argp1 = 0 ;
43356 int res1 = 0 ;
43357 wxColour temp2 ;
43358 PyObject * obj0 = 0 ;
43359 PyObject * obj1 = 0 ;
43360 char * kwnames[] = {
43361 (char *) "self",(char *) "colBack", NULL
43362 };
43363
43364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43366 if (!SWIG_IsOK(res1)) {
43367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43368 }
43369 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43370 {
43371 arg2 = &temp2;
43372 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43373 }
43374 {
43375 PyThreadState* __tstate = wxPyBeginAllowThreads();
43376 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43377 wxPyEndAllowThreads(__tstate);
43378 if (PyErr_Occurred()) SWIG_fail;
43379 }
43380 resultobj = SWIG_Py_Void();
43381 return resultobj;
43382 fail:
43383 return NULL;
43384 }
43385
43386
43387 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43388 PyObject *resultobj = 0;
43389 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43390 wxColour result;
43391 void *argp1 = 0 ;
43392 int res1 = 0 ;
43393 PyObject *swig_obj[1] ;
43394
43395 if (!args) SWIG_fail;
43396 swig_obj[0] = args;
43397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43398 if (!SWIG_IsOK(res1)) {
43399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43400 }
43401 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43402 {
43403 PyThreadState* __tstate = wxPyBeginAllowThreads();
43404 result = wxMenuItem_GetBackgroundColour(arg1);
43405 wxPyEndAllowThreads(__tstate);
43406 if (PyErr_Occurred()) SWIG_fail;
43407 }
43408 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43409 return resultobj;
43410 fail:
43411 return NULL;
43412 }
43413
43414
43415 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43416 PyObject *resultobj = 0;
43417 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43418 wxBitmap *arg2 = 0 ;
43419 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43420 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43421 void *argp1 = 0 ;
43422 int res1 = 0 ;
43423 void *argp2 = 0 ;
43424 int res2 = 0 ;
43425 void *argp3 = 0 ;
43426 int res3 = 0 ;
43427 PyObject * obj0 = 0 ;
43428 PyObject * obj1 = 0 ;
43429 PyObject * obj2 = 0 ;
43430 char * kwnames[] = {
43431 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43432 };
43433
43434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43436 if (!SWIG_IsOK(res1)) {
43437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43438 }
43439 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43440 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43441 if (!SWIG_IsOK(res2)) {
43442 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43443 }
43444 if (!argp2) {
43445 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43446 }
43447 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43448 if (obj2) {
43449 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43450 if (!SWIG_IsOK(res3)) {
43451 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43452 }
43453 if (!argp3) {
43454 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43455 }
43456 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43457 }
43458 {
43459 PyThreadState* __tstate = wxPyBeginAllowThreads();
43460 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43461 wxPyEndAllowThreads(__tstate);
43462 if (PyErr_Occurred()) SWIG_fail;
43463 }
43464 resultobj = SWIG_Py_Void();
43465 return resultobj;
43466 fail:
43467 return NULL;
43468 }
43469
43470
43471 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43472 PyObject *resultobj = 0;
43473 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43474 wxBitmap *arg2 = 0 ;
43475 void *argp1 = 0 ;
43476 int res1 = 0 ;
43477 void *argp2 = 0 ;
43478 int res2 = 0 ;
43479 PyObject * obj0 = 0 ;
43480 PyObject * obj1 = 0 ;
43481 char * kwnames[] = {
43482 (char *) "self",(char *) "bmpDisabled", NULL
43483 };
43484
43485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43487 if (!SWIG_IsOK(res1)) {
43488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43489 }
43490 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43491 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43492 if (!SWIG_IsOK(res2)) {
43493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43494 }
43495 if (!argp2) {
43496 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43497 }
43498 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43499 {
43500 PyThreadState* __tstate = wxPyBeginAllowThreads();
43501 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43502 wxPyEndAllowThreads(__tstate);
43503 if (PyErr_Occurred()) SWIG_fail;
43504 }
43505 resultobj = SWIG_Py_Void();
43506 return resultobj;
43507 fail:
43508 return NULL;
43509 }
43510
43511
43512 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43513 PyObject *resultobj = 0;
43514 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43515 wxBitmap *result = 0 ;
43516 void *argp1 = 0 ;
43517 int res1 = 0 ;
43518 PyObject *swig_obj[1] ;
43519
43520 if (!args) SWIG_fail;
43521 swig_obj[0] = args;
43522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43523 if (!SWIG_IsOK(res1)) {
43524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43525 }
43526 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43527 {
43528 PyThreadState* __tstate = wxPyBeginAllowThreads();
43529 {
43530 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43531 result = (wxBitmap *) &_result_ref;
43532 }
43533 wxPyEndAllowThreads(__tstate);
43534 if (PyErr_Occurred()) SWIG_fail;
43535 }
43536 {
43537 wxBitmap* resultptr = new wxBitmap(*result);
43538 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43539 }
43540 return resultobj;
43541 fail:
43542 return NULL;
43543 }
43544
43545
43546 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43547 PyObject *resultobj = 0;
43548 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43549 int arg2 ;
43550 void *argp1 = 0 ;
43551 int res1 = 0 ;
43552 int val2 ;
43553 int ecode2 = 0 ;
43554 PyObject * obj0 = 0 ;
43555 PyObject * obj1 = 0 ;
43556 char * kwnames[] = {
43557 (char *) "self",(char *) "nWidth", NULL
43558 };
43559
43560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43562 if (!SWIG_IsOK(res1)) {
43563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43564 }
43565 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43566 ecode2 = SWIG_AsVal_int(obj1, &val2);
43567 if (!SWIG_IsOK(ecode2)) {
43568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43569 }
43570 arg2 = static_cast< int >(val2);
43571 {
43572 PyThreadState* __tstate = wxPyBeginAllowThreads();
43573 wxMenuItem_SetMarginWidth(arg1,arg2);
43574 wxPyEndAllowThreads(__tstate);
43575 if (PyErr_Occurred()) SWIG_fail;
43576 }
43577 resultobj = SWIG_Py_Void();
43578 return resultobj;
43579 fail:
43580 return NULL;
43581 }
43582
43583
43584 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43585 PyObject *resultobj = 0;
43586 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43587 int result;
43588 void *argp1 = 0 ;
43589 int res1 = 0 ;
43590 PyObject *swig_obj[1] ;
43591
43592 if (!args) SWIG_fail;
43593 swig_obj[0] = args;
43594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43595 if (!SWIG_IsOK(res1)) {
43596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43597 }
43598 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43599 {
43600 PyThreadState* __tstate = wxPyBeginAllowThreads();
43601 result = (int)wxMenuItem_GetMarginWidth(arg1);
43602 wxPyEndAllowThreads(__tstate);
43603 if (PyErr_Occurred()) SWIG_fail;
43604 }
43605 resultobj = SWIG_From_int(static_cast< int >(result));
43606 return resultobj;
43607 fail:
43608 return NULL;
43609 }
43610
43611
43612 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43613 PyObject *resultobj = 0;
43614 int result;
43615
43616 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43617 {
43618 PyThreadState* __tstate = wxPyBeginAllowThreads();
43619 result = (int)wxMenuItem_GetDefaultMarginWidth();
43620 wxPyEndAllowThreads(__tstate);
43621 if (PyErr_Occurred()) SWIG_fail;
43622 }
43623 resultobj = SWIG_From_int(static_cast< int >(result));
43624 return resultobj;
43625 fail:
43626 return NULL;
43627 }
43628
43629
43630 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43631 PyObject *resultobj = 0;
43632 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43633 bool result;
43634 void *argp1 = 0 ;
43635 int res1 = 0 ;
43636 PyObject *swig_obj[1] ;
43637
43638 if (!args) SWIG_fail;
43639 swig_obj[0] = args;
43640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43641 if (!SWIG_IsOK(res1)) {
43642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43643 }
43644 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43645 {
43646 PyThreadState* __tstate = wxPyBeginAllowThreads();
43647 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43648 wxPyEndAllowThreads(__tstate);
43649 if (PyErr_Occurred()) SWIG_fail;
43650 }
43651 {
43652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43653 }
43654 return resultobj;
43655 fail:
43656 return NULL;
43657 }
43658
43659
43660 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43661 PyObject *resultobj = 0;
43662 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43663 bool arg2 = (bool) true ;
43664 void *argp1 = 0 ;
43665 int res1 = 0 ;
43666 bool val2 ;
43667 int ecode2 = 0 ;
43668 PyObject * obj0 = 0 ;
43669 PyObject * obj1 = 0 ;
43670 char * kwnames[] = {
43671 (char *) "self",(char *) "ownerDrawn", NULL
43672 };
43673
43674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43676 if (!SWIG_IsOK(res1)) {
43677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43678 }
43679 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43680 if (obj1) {
43681 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43682 if (!SWIG_IsOK(ecode2)) {
43683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43684 }
43685 arg2 = static_cast< bool >(val2);
43686 }
43687 {
43688 PyThreadState* __tstate = wxPyBeginAllowThreads();
43689 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43690 wxPyEndAllowThreads(__tstate);
43691 if (PyErr_Occurred()) SWIG_fail;
43692 }
43693 resultobj = SWIG_Py_Void();
43694 return resultobj;
43695 fail:
43696 return NULL;
43697 }
43698
43699
43700 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43701 PyObject *resultobj = 0;
43702 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43703 void *argp1 = 0 ;
43704 int res1 = 0 ;
43705 PyObject *swig_obj[1] ;
43706
43707 if (!args) SWIG_fail;
43708 swig_obj[0] = args;
43709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43710 if (!SWIG_IsOK(res1)) {
43711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43712 }
43713 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43714 {
43715 PyThreadState* __tstate = wxPyBeginAllowThreads();
43716 wxMenuItem_ResetOwnerDrawn(arg1);
43717 wxPyEndAllowThreads(__tstate);
43718 if (PyErr_Occurred()) SWIG_fail;
43719 }
43720 resultobj = SWIG_Py_Void();
43721 return resultobj;
43722 fail:
43723 return NULL;
43724 }
43725
43726
43727 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43728 PyObject *obj;
43729 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43730 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43731 return SWIG_Py_Void();
43732 }
43733
43734 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43735 return SWIG_Python_InitShadowInstance(args);
43736 }
43737
43738 SWIGINTERN int ControlNameStr_set(PyObject *) {
43739 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43740 return 1;
43741 }
43742
43743
43744 SWIGINTERN PyObject *ControlNameStr_get(void) {
43745 PyObject *pyobj = 0;
43746
43747 {
43748 #if wxUSE_UNICODE
43749 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43750 #else
43751 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43752 #endif
43753 }
43754 return pyobj;
43755 }
43756
43757
43758 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43759 PyObject *resultobj = 0;
43760 wxWindow *arg1 = (wxWindow *) 0 ;
43761 int arg2 = (int) -1 ;
43762 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43763 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43764 wxSize const &arg4_defvalue = wxDefaultSize ;
43765 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43766 long arg5 = (long) 0 ;
43767 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43768 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43769 wxString const &arg7_defvalue = wxPyControlNameStr ;
43770 wxString *arg7 = (wxString *) &arg7_defvalue ;
43771 wxControl *result = 0 ;
43772 void *argp1 = 0 ;
43773 int res1 = 0 ;
43774 int val2 ;
43775 int ecode2 = 0 ;
43776 wxPoint temp3 ;
43777 wxSize temp4 ;
43778 long val5 ;
43779 int ecode5 = 0 ;
43780 void *argp6 = 0 ;
43781 int res6 = 0 ;
43782 bool temp7 = false ;
43783 PyObject * obj0 = 0 ;
43784 PyObject * obj1 = 0 ;
43785 PyObject * obj2 = 0 ;
43786 PyObject * obj3 = 0 ;
43787 PyObject * obj4 = 0 ;
43788 PyObject * obj5 = 0 ;
43789 PyObject * obj6 = 0 ;
43790 char * kwnames[] = {
43791 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43792 };
43793
43794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43796 if (!SWIG_IsOK(res1)) {
43797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43798 }
43799 arg1 = reinterpret_cast< wxWindow * >(argp1);
43800 if (obj1) {
43801 ecode2 = SWIG_AsVal_int(obj1, &val2);
43802 if (!SWIG_IsOK(ecode2)) {
43803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43804 }
43805 arg2 = static_cast< int >(val2);
43806 }
43807 if (obj2) {
43808 {
43809 arg3 = &temp3;
43810 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43811 }
43812 }
43813 if (obj3) {
43814 {
43815 arg4 = &temp4;
43816 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43817 }
43818 }
43819 if (obj4) {
43820 ecode5 = SWIG_AsVal_long(obj4, &val5);
43821 if (!SWIG_IsOK(ecode5)) {
43822 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43823 }
43824 arg5 = static_cast< long >(val5);
43825 }
43826 if (obj5) {
43827 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43828 if (!SWIG_IsOK(res6)) {
43829 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43830 }
43831 if (!argp6) {
43832 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43833 }
43834 arg6 = reinterpret_cast< wxValidator * >(argp6);
43835 }
43836 if (obj6) {
43837 {
43838 arg7 = wxString_in_helper(obj6);
43839 if (arg7 == NULL) SWIG_fail;
43840 temp7 = true;
43841 }
43842 }
43843 {
43844 if (!wxPyCheckForApp()) SWIG_fail;
43845 PyThreadState* __tstate = wxPyBeginAllowThreads();
43846 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43847 wxPyEndAllowThreads(__tstate);
43848 if (PyErr_Occurred()) SWIG_fail;
43849 }
43850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43851 {
43852 if (temp7)
43853 delete arg7;
43854 }
43855 return resultobj;
43856 fail:
43857 {
43858 if (temp7)
43859 delete arg7;
43860 }
43861 return NULL;
43862 }
43863
43864
43865 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43866 PyObject *resultobj = 0;
43867 wxControl *result = 0 ;
43868
43869 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43870 {
43871 if (!wxPyCheckForApp()) SWIG_fail;
43872 PyThreadState* __tstate = wxPyBeginAllowThreads();
43873 result = (wxControl *)new wxControl();
43874 wxPyEndAllowThreads(__tstate);
43875 if (PyErr_Occurred()) SWIG_fail;
43876 }
43877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43878 return resultobj;
43879 fail:
43880 return NULL;
43881 }
43882
43883
43884 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43885 PyObject *resultobj = 0;
43886 wxControl *arg1 = (wxControl *) 0 ;
43887 wxWindow *arg2 = (wxWindow *) 0 ;
43888 int arg3 = (int) -1 ;
43889 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43890 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43891 wxSize const &arg5_defvalue = wxDefaultSize ;
43892 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43893 long arg6 = (long) 0 ;
43894 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43895 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43896 wxString const &arg8_defvalue = wxPyControlNameStr ;
43897 wxString *arg8 = (wxString *) &arg8_defvalue ;
43898 bool result;
43899 void *argp1 = 0 ;
43900 int res1 = 0 ;
43901 void *argp2 = 0 ;
43902 int res2 = 0 ;
43903 int val3 ;
43904 int ecode3 = 0 ;
43905 wxPoint temp4 ;
43906 wxSize temp5 ;
43907 long val6 ;
43908 int ecode6 = 0 ;
43909 void *argp7 = 0 ;
43910 int res7 = 0 ;
43911 bool temp8 = false ;
43912 PyObject * obj0 = 0 ;
43913 PyObject * obj1 = 0 ;
43914 PyObject * obj2 = 0 ;
43915 PyObject * obj3 = 0 ;
43916 PyObject * obj4 = 0 ;
43917 PyObject * obj5 = 0 ;
43918 PyObject * obj6 = 0 ;
43919 PyObject * obj7 = 0 ;
43920 char * kwnames[] = {
43921 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43922 };
43923
43924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43926 if (!SWIG_IsOK(res1)) {
43927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43928 }
43929 arg1 = reinterpret_cast< wxControl * >(argp1);
43930 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43931 if (!SWIG_IsOK(res2)) {
43932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43933 }
43934 arg2 = reinterpret_cast< wxWindow * >(argp2);
43935 if (obj2) {
43936 ecode3 = SWIG_AsVal_int(obj2, &val3);
43937 if (!SWIG_IsOK(ecode3)) {
43938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43939 }
43940 arg3 = static_cast< int >(val3);
43941 }
43942 if (obj3) {
43943 {
43944 arg4 = &temp4;
43945 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43946 }
43947 }
43948 if (obj4) {
43949 {
43950 arg5 = &temp5;
43951 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43952 }
43953 }
43954 if (obj5) {
43955 ecode6 = SWIG_AsVal_long(obj5, &val6);
43956 if (!SWIG_IsOK(ecode6)) {
43957 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43958 }
43959 arg6 = static_cast< long >(val6);
43960 }
43961 if (obj6) {
43962 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43963 if (!SWIG_IsOK(res7)) {
43964 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43965 }
43966 if (!argp7) {
43967 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43968 }
43969 arg7 = reinterpret_cast< wxValidator * >(argp7);
43970 }
43971 if (obj7) {
43972 {
43973 arg8 = wxString_in_helper(obj7);
43974 if (arg8 == NULL) SWIG_fail;
43975 temp8 = true;
43976 }
43977 }
43978 {
43979 PyThreadState* __tstate = wxPyBeginAllowThreads();
43980 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43981 wxPyEndAllowThreads(__tstate);
43982 if (PyErr_Occurred()) SWIG_fail;
43983 }
43984 {
43985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43986 }
43987 {
43988 if (temp8)
43989 delete arg8;
43990 }
43991 return resultobj;
43992 fail:
43993 {
43994 if (temp8)
43995 delete arg8;
43996 }
43997 return NULL;
43998 }
43999
44000
44001 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44002 PyObject *resultobj = 0;
44003 wxControl *arg1 = (wxControl *) 0 ;
44004 wxCommandEvent *arg2 = 0 ;
44005 void *argp1 = 0 ;
44006 int res1 = 0 ;
44007 void *argp2 = 0 ;
44008 int res2 = 0 ;
44009 PyObject * obj0 = 0 ;
44010 PyObject * obj1 = 0 ;
44011 char * kwnames[] = {
44012 (char *) "self",(char *) "event", NULL
44013 };
44014
44015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44017 if (!SWIG_IsOK(res1)) {
44018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44019 }
44020 arg1 = reinterpret_cast< wxControl * >(argp1);
44021 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44022 if (!SWIG_IsOK(res2)) {
44023 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44024 }
44025 if (!argp2) {
44026 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44027 }
44028 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44029 {
44030 PyThreadState* __tstate = wxPyBeginAllowThreads();
44031 (arg1)->Command(*arg2);
44032 wxPyEndAllowThreads(__tstate);
44033 if (PyErr_Occurred()) SWIG_fail;
44034 }
44035 resultobj = SWIG_Py_Void();
44036 return resultobj;
44037 fail:
44038 return NULL;
44039 }
44040
44041
44042 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44043 PyObject *resultobj = 0;
44044 wxControl *arg1 = (wxControl *) 0 ;
44045 wxString result;
44046 void *argp1 = 0 ;
44047 int res1 = 0 ;
44048 PyObject *swig_obj[1] ;
44049
44050 if (!args) SWIG_fail;
44051 swig_obj[0] = args;
44052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44053 if (!SWIG_IsOK(res1)) {
44054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44055 }
44056 arg1 = reinterpret_cast< wxControl * >(argp1);
44057 {
44058 PyThreadState* __tstate = wxPyBeginAllowThreads();
44059 result = (arg1)->GetLabel();
44060 wxPyEndAllowThreads(__tstate);
44061 if (PyErr_Occurred()) SWIG_fail;
44062 }
44063 {
44064 #if wxUSE_UNICODE
44065 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44066 #else
44067 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44068 #endif
44069 }
44070 return resultobj;
44071 fail:
44072 return NULL;
44073 }
44074
44075
44076 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44077 PyObject *resultobj = 0;
44078 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44079 SwigValueWrapper<wxVisualAttributes > result;
44080 int val1 ;
44081 int ecode1 = 0 ;
44082 PyObject * obj0 = 0 ;
44083 char * kwnames[] = {
44084 (char *) "variant", NULL
44085 };
44086
44087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44088 if (obj0) {
44089 ecode1 = SWIG_AsVal_int(obj0, &val1);
44090 if (!SWIG_IsOK(ecode1)) {
44091 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44092 }
44093 arg1 = static_cast< wxWindowVariant >(val1);
44094 }
44095 {
44096 if (!wxPyCheckForApp()) SWIG_fail;
44097 PyThreadState* __tstate = wxPyBeginAllowThreads();
44098 result = wxControl::GetClassDefaultAttributes(arg1);
44099 wxPyEndAllowThreads(__tstate);
44100 if (PyErr_Occurred()) SWIG_fail;
44101 }
44102 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44103 return resultobj;
44104 fail:
44105 return NULL;
44106 }
44107
44108
44109 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44110 PyObject *obj;
44111 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44112 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44113 return SWIG_Py_Void();
44114 }
44115
44116 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44117 return SWIG_Python_InitShadowInstance(args);
44118 }
44119
44120 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44121 PyObject *resultobj = 0;
44122 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44123 wxString *arg2 = 0 ;
44124 PyObject *arg3 = (PyObject *) NULL ;
44125 int result;
44126 void *argp1 = 0 ;
44127 int res1 = 0 ;
44128 bool temp2 = false ;
44129 PyObject * obj0 = 0 ;
44130 PyObject * obj1 = 0 ;
44131 PyObject * obj2 = 0 ;
44132 char * kwnames[] = {
44133 (char *) "self",(char *) "item",(char *) "clientData", NULL
44134 };
44135
44136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44138 if (!SWIG_IsOK(res1)) {
44139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44140 }
44141 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44142 {
44143 arg2 = wxString_in_helper(obj1);
44144 if (arg2 == NULL) SWIG_fail;
44145 temp2 = true;
44146 }
44147 if (obj2) {
44148 arg3 = obj2;
44149 }
44150 {
44151 PyThreadState* __tstate = wxPyBeginAllowThreads();
44152 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44153 wxPyEndAllowThreads(__tstate);
44154 if (PyErr_Occurred()) SWIG_fail;
44155 }
44156 resultobj = SWIG_From_int(static_cast< int >(result));
44157 {
44158 if (temp2)
44159 delete arg2;
44160 }
44161 return resultobj;
44162 fail:
44163 {
44164 if (temp2)
44165 delete arg2;
44166 }
44167 return NULL;
44168 }
44169
44170
44171 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44172 PyObject *resultobj = 0;
44173 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44174 wxArrayString *arg2 = 0 ;
44175 void *argp1 = 0 ;
44176 int res1 = 0 ;
44177 bool temp2 = false ;
44178 PyObject * obj0 = 0 ;
44179 PyObject * obj1 = 0 ;
44180 char * kwnames[] = {
44181 (char *) "self",(char *) "strings", NULL
44182 };
44183
44184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44186 if (!SWIG_IsOK(res1)) {
44187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44188 }
44189 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44190 {
44191 if (! PySequence_Check(obj1)) {
44192 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44193 SWIG_fail;
44194 }
44195 arg2 = new wxArrayString;
44196 temp2 = true;
44197 int i, len=PySequence_Length(obj1);
44198 for (i=0; i<len; i++) {
44199 PyObject* item = PySequence_GetItem(obj1, i);
44200 wxString* s = wxString_in_helper(item);
44201 if (PyErr_Occurred()) SWIG_fail;
44202 arg2->Add(*s);
44203 delete s;
44204 Py_DECREF(item);
44205 }
44206 }
44207 {
44208 PyThreadState* __tstate = wxPyBeginAllowThreads();
44209 (arg1)->Append((wxArrayString const &)*arg2);
44210 wxPyEndAllowThreads(__tstate);
44211 if (PyErr_Occurred()) SWIG_fail;
44212 }
44213 resultobj = SWIG_Py_Void();
44214 {
44215 if (temp2) delete arg2;
44216 }
44217 return resultobj;
44218 fail:
44219 {
44220 if (temp2) delete arg2;
44221 }
44222 return NULL;
44223 }
44224
44225
44226 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44227 PyObject *resultobj = 0;
44228 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44229 wxString *arg2 = 0 ;
44230 unsigned int arg3 ;
44231 PyObject *arg4 = (PyObject *) NULL ;
44232 int result;
44233 void *argp1 = 0 ;
44234 int res1 = 0 ;
44235 bool temp2 = false ;
44236 unsigned int val3 ;
44237 int ecode3 = 0 ;
44238 PyObject * obj0 = 0 ;
44239 PyObject * obj1 = 0 ;
44240 PyObject * obj2 = 0 ;
44241 PyObject * obj3 = 0 ;
44242 char * kwnames[] = {
44243 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44244 };
44245
44246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44248 if (!SWIG_IsOK(res1)) {
44249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44250 }
44251 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44252 {
44253 arg2 = wxString_in_helper(obj1);
44254 if (arg2 == NULL) SWIG_fail;
44255 temp2 = true;
44256 }
44257 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44258 if (!SWIG_IsOK(ecode3)) {
44259 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44260 }
44261 arg3 = static_cast< unsigned int >(val3);
44262 if (obj3) {
44263 arg4 = obj3;
44264 }
44265 {
44266 PyThreadState* __tstate = wxPyBeginAllowThreads();
44267 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44268 wxPyEndAllowThreads(__tstate);
44269 if (PyErr_Occurred()) SWIG_fail;
44270 }
44271 resultobj = SWIG_From_int(static_cast< int >(result));
44272 {
44273 if (temp2)
44274 delete arg2;
44275 }
44276 return resultobj;
44277 fail:
44278 {
44279 if (temp2)
44280 delete arg2;
44281 }
44282 return NULL;
44283 }
44284
44285
44286 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44287 PyObject *resultobj = 0;
44288 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44289 void *argp1 = 0 ;
44290 int res1 = 0 ;
44291 PyObject *swig_obj[1] ;
44292
44293 if (!args) SWIG_fail;
44294 swig_obj[0] = args;
44295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44296 if (!SWIG_IsOK(res1)) {
44297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44298 }
44299 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44300 {
44301 PyThreadState* __tstate = wxPyBeginAllowThreads();
44302 (arg1)->Clear();
44303 wxPyEndAllowThreads(__tstate);
44304 if (PyErr_Occurred()) SWIG_fail;
44305 }
44306 resultobj = SWIG_Py_Void();
44307 return resultobj;
44308 fail:
44309 return NULL;
44310 }
44311
44312
44313 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44314 PyObject *resultobj = 0;
44315 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44316 unsigned int arg2 ;
44317 void *argp1 = 0 ;
44318 int res1 = 0 ;
44319 unsigned int val2 ;
44320 int ecode2 = 0 ;
44321 PyObject * obj0 = 0 ;
44322 PyObject * obj1 = 0 ;
44323 char * kwnames[] = {
44324 (char *) "self",(char *) "n", NULL
44325 };
44326
44327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44329 if (!SWIG_IsOK(res1)) {
44330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44331 }
44332 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44333 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44334 if (!SWIG_IsOK(ecode2)) {
44335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44336 }
44337 arg2 = static_cast< unsigned int >(val2);
44338 {
44339 PyThreadState* __tstate = wxPyBeginAllowThreads();
44340 (arg1)->Delete(arg2);
44341 wxPyEndAllowThreads(__tstate);
44342 if (PyErr_Occurred()) SWIG_fail;
44343 }
44344 resultobj = SWIG_Py_Void();
44345 return resultobj;
44346 fail:
44347 return NULL;
44348 }
44349
44350
44351 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44352 PyObject *resultobj = 0;
44353 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44354 unsigned int arg2 ;
44355 PyObject *result = 0 ;
44356 void *argp1 = 0 ;
44357 int res1 = 0 ;
44358 unsigned int val2 ;
44359 int ecode2 = 0 ;
44360 PyObject * obj0 = 0 ;
44361 PyObject * obj1 = 0 ;
44362 char * kwnames[] = {
44363 (char *) "self",(char *) "n", NULL
44364 };
44365
44366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44368 if (!SWIG_IsOK(res1)) {
44369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44370 }
44371 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44372 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44373 if (!SWIG_IsOK(ecode2)) {
44374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44375 }
44376 arg2 = static_cast< unsigned int >(val2);
44377 {
44378 PyThreadState* __tstate = wxPyBeginAllowThreads();
44379 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44380 wxPyEndAllowThreads(__tstate);
44381 if (PyErr_Occurred()) SWIG_fail;
44382 }
44383 resultobj = result;
44384 return resultobj;
44385 fail:
44386 return NULL;
44387 }
44388
44389
44390 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44391 PyObject *resultobj = 0;
44392 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44393 unsigned int arg2 ;
44394 PyObject *arg3 = (PyObject *) 0 ;
44395 void *argp1 = 0 ;
44396 int res1 = 0 ;
44397 unsigned int val2 ;
44398 int ecode2 = 0 ;
44399 PyObject * obj0 = 0 ;
44400 PyObject * obj1 = 0 ;
44401 PyObject * obj2 = 0 ;
44402 char * kwnames[] = {
44403 (char *) "self",(char *) "n",(char *) "clientData", NULL
44404 };
44405
44406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44408 if (!SWIG_IsOK(res1)) {
44409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44410 }
44411 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44412 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44413 if (!SWIG_IsOK(ecode2)) {
44414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44415 }
44416 arg2 = static_cast< unsigned int >(val2);
44417 arg3 = obj2;
44418 {
44419 PyThreadState* __tstate = wxPyBeginAllowThreads();
44420 wxItemContainer_SetClientData(arg1,arg2,arg3);
44421 wxPyEndAllowThreads(__tstate);
44422 if (PyErr_Occurred()) SWIG_fail;
44423 }
44424 resultobj = SWIG_Py_Void();
44425 return resultobj;
44426 fail:
44427 return NULL;
44428 }
44429
44430
44431 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44432 PyObject *resultobj = 0;
44433 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44434 unsigned int result;
44435 void *argp1 = 0 ;
44436 int res1 = 0 ;
44437 PyObject *swig_obj[1] ;
44438
44439 if (!args) SWIG_fail;
44440 swig_obj[0] = args;
44441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44442 if (!SWIG_IsOK(res1)) {
44443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44444 }
44445 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44446 {
44447 PyThreadState* __tstate = wxPyBeginAllowThreads();
44448 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44449 wxPyEndAllowThreads(__tstate);
44450 if (PyErr_Occurred()) SWIG_fail;
44451 }
44452 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44453 return resultobj;
44454 fail:
44455 return NULL;
44456 }
44457
44458
44459 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44460 PyObject *resultobj = 0;
44461 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44462 bool result;
44463 void *argp1 = 0 ;
44464 int res1 = 0 ;
44465 PyObject *swig_obj[1] ;
44466
44467 if (!args) SWIG_fail;
44468 swig_obj[0] = args;
44469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44470 if (!SWIG_IsOK(res1)) {
44471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44472 }
44473 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44474 {
44475 PyThreadState* __tstate = wxPyBeginAllowThreads();
44476 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44477 wxPyEndAllowThreads(__tstate);
44478 if (PyErr_Occurred()) SWIG_fail;
44479 }
44480 {
44481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44482 }
44483 return resultobj;
44484 fail:
44485 return NULL;
44486 }
44487
44488
44489 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44490 PyObject *resultobj = 0;
44491 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44492 unsigned int arg2 ;
44493 wxString result;
44494 void *argp1 = 0 ;
44495 int res1 = 0 ;
44496 unsigned int val2 ;
44497 int ecode2 = 0 ;
44498 PyObject * obj0 = 0 ;
44499 PyObject * obj1 = 0 ;
44500 char * kwnames[] = {
44501 (char *) "self",(char *) "n", NULL
44502 };
44503
44504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44506 if (!SWIG_IsOK(res1)) {
44507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44508 }
44509 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44510 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44511 if (!SWIG_IsOK(ecode2)) {
44512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44513 }
44514 arg2 = static_cast< unsigned int >(val2);
44515 {
44516 PyThreadState* __tstate = wxPyBeginAllowThreads();
44517 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44518 wxPyEndAllowThreads(__tstate);
44519 if (PyErr_Occurred()) SWIG_fail;
44520 }
44521 {
44522 #if wxUSE_UNICODE
44523 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44524 #else
44525 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44526 #endif
44527 }
44528 return resultobj;
44529 fail:
44530 return NULL;
44531 }
44532
44533
44534 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44535 PyObject *resultobj = 0;
44536 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44537 wxArrayString result;
44538 void *argp1 = 0 ;
44539 int res1 = 0 ;
44540 PyObject *swig_obj[1] ;
44541
44542 if (!args) SWIG_fail;
44543 swig_obj[0] = args;
44544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44545 if (!SWIG_IsOK(res1)) {
44546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44547 }
44548 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44549 {
44550 PyThreadState* __tstate = wxPyBeginAllowThreads();
44551 result = ((wxItemContainer const *)arg1)->GetStrings();
44552 wxPyEndAllowThreads(__tstate);
44553 if (PyErr_Occurred()) SWIG_fail;
44554 }
44555 {
44556 resultobj = wxArrayString2PyList_helper(result);
44557 }
44558 return resultobj;
44559 fail:
44560 return NULL;
44561 }
44562
44563
44564 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44565 PyObject *resultobj = 0;
44566 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44567 unsigned int arg2 ;
44568 wxString *arg3 = 0 ;
44569 void *argp1 = 0 ;
44570 int res1 = 0 ;
44571 unsigned int val2 ;
44572 int ecode2 = 0 ;
44573 bool temp3 = false ;
44574 PyObject * obj0 = 0 ;
44575 PyObject * obj1 = 0 ;
44576 PyObject * obj2 = 0 ;
44577 char * kwnames[] = {
44578 (char *) "self",(char *) "n",(char *) "s", NULL
44579 };
44580
44581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44583 if (!SWIG_IsOK(res1)) {
44584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44585 }
44586 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44587 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44588 if (!SWIG_IsOK(ecode2)) {
44589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44590 }
44591 arg2 = static_cast< unsigned int >(val2);
44592 {
44593 arg3 = wxString_in_helper(obj2);
44594 if (arg3 == NULL) SWIG_fail;
44595 temp3 = true;
44596 }
44597 {
44598 PyThreadState* __tstate = wxPyBeginAllowThreads();
44599 (arg1)->SetString(arg2,(wxString const &)*arg3);
44600 wxPyEndAllowThreads(__tstate);
44601 if (PyErr_Occurred()) SWIG_fail;
44602 }
44603 resultobj = SWIG_Py_Void();
44604 {
44605 if (temp3)
44606 delete arg3;
44607 }
44608 return resultobj;
44609 fail:
44610 {
44611 if (temp3)
44612 delete arg3;
44613 }
44614 return NULL;
44615 }
44616
44617
44618 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44619 PyObject *resultobj = 0;
44620 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44621 wxString *arg2 = 0 ;
44622 int result;
44623 void *argp1 = 0 ;
44624 int res1 = 0 ;
44625 bool temp2 = false ;
44626 PyObject * obj0 = 0 ;
44627 PyObject * obj1 = 0 ;
44628 char * kwnames[] = {
44629 (char *) "self",(char *) "s", NULL
44630 };
44631
44632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44634 if (!SWIG_IsOK(res1)) {
44635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44636 }
44637 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44638 {
44639 arg2 = wxString_in_helper(obj1);
44640 if (arg2 == NULL) SWIG_fail;
44641 temp2 = true;
44642 }
44643 {
44644 PyThreadState* __tstate = wxPyBeginAllowThreads();
44645 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44646 wxPyEndAllowThreads(__tstate);
44647 if (PyErr_Occurred()) SWIG_fail;
44648 }
44649 resultobj = SWIG_From_int(static_cast< int >(result));
44650 {
44651 if (temp2)
44652 delete arg2;
44653 }
44654 return resultobj;
44655 fail:
44656 {
44657 if (temp2)
44658 delete arg2;
44659 }
44660 return NULL;
44661 }
44662
44663
44664 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44665 PyObject *resultobj = 0;
44666 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44667 int arg2 ;
44668 void *argp1 = 0 ;
44669 int res1 = 0 ;
44670 int val2 ;
44671 int ecode2 = 0 ;
44672 PyObject * obj0 = 0 ;
44673 PyObject * obj1 = 0 ;
44674 char * kwnames[] = {
44675 (char *) "self",(char *) "n", NULL
44676 };
44677
44678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44680 if (!SWIG_IsOK(res1)) {
44681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44682 }
44683 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44684 ecode2 = SWIG_AsVal_int(obj1, &val2);
44685 if (!SWIG_IsOK(ecode2)) {
44686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44687 }
44688 arg2 = static_cast< int >(val2);
44689 {
44690 PyThreadState* __tstate = wxPyBeginAllowThreads();
44691 (arg1)->SetSelection(arg2);
44692 wxPyEndAllowThreads(__tstate);
44693 if (PyErr_Occurred()) SWIG_fail;
44694 }
44695 resultobj = SWIG_Py_Void();
44696 return resultobj;
44697 fail:
44698 return NULL;
44699 }
44700
44701
44702 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44703 PyObject *resultobj = 0;
44704 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44705 int result;
44706 void *argp1 = 0 ;
44707 int res1 = 0 ;
44708 PyObject *swig_obj[1] ;
44709
44710 if (!args) SWIG_fail;
44711 swig_obj[0] = args;
44712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44713 if (!SWIG_IsOK(res1)) {
44714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44715 }
44716 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44717 {
44718 PyThreadState* __tstate = wxPyBeginAllowThreads();
44719 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44720 wxPyEndAllowThreads(__tstate);
44721 if (PyErr_Occurred()) SWIG_fail;
44722 }
44723 resultobj = SWIG_From_int(static_cast< int >(result));
44724 return resultobj;
44725 fail:
44726 return NULL;
44727 }
44728
44729
44730 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44731 PyObject *resultobj = 0;
44732 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44733 wxString *arg2 = 0 ;
44734 bool result;
44735 void *argp1 = 0 ;
44736 int res1 = 0 ;
44737 bool temp2 = false ;
44738 PyObject * obj0 = 0 ;
44739 PyObject * obj1 = 0 ;
44740 char * kwnames[] = {
44741 (char *) "self",(char *) "s", NULL
44742 };
44743
44744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44746 if (!SWIG_IsOK(res1)) {
44747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44748 }
44749 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44750 {
44751 arg2 = wxString_in_helper(obj1);
44752 if (arg2 == NULL) SWIG_fail;
44753 temp2 = true;
44754 }
44755 {
44756 PyThreadState* __tstate = wxPyBeginAllowThreads();
44757 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44758 wxPyEndAllowThreads(__tstate);
44759 if (PyErr_Occurred()) SWIG_fail;
44760 }
44761 {
44762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44763 }
44764 {
44765 if (temp2)
44766 delete arg2;
44767 }
44768 return resultobj;
44769 fail:
44770 {
44771 if (temp2)
44772 delete arg2;
44773 }
44774 return NULL;
44775 }
44776
44777
44778 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44779 PyObject *resultobj = 0;
44780 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44781 wxString result;
44782 void *argp1 = 0 ;
44783 int res1 = 0 ;
44784 PyObject *swig_obj[1] ;
44785
44786 if (!args) SWIG_fail;
44787 swig_obj[0] = args;
44788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44789 if (!SWIG_IsOK(res1)) {
44790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44791 }
44792 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44793 {
44794 PyThreadState* __tstate = wxPyBeginAllowThreads();
44795 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44796 wxPyEndAllowThreads(__tstate);
44797 if (PyErr_Occurred()) SWIG_fail;
44798 }
44799 {
44800 #if wxUSE_UNICODE
44801 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44802 #else
44803 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44804 #endif
44805 }
44806 return resultobj;
44807 fail:
44808 return NULL;
44809 }
44810
44811
44812 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44813 PyObject *resultobj = 0;
44814 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44815 int arg2 ;
44816 void *argp1 = 0 ;
44817 int res1 = 0 ;
44818 int val2 ;
44819 int ecode2 = 0 ;
44820 PyObject * obj0 = 0 ;
44821 PyObject * obj1 = 0 ;
44822 char * kwnames[] = {
44823 (char *) "self",(char *) "n", NULL
44824 };
44825
44826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44828 if (!SWIG_IsOK(res1)) {
44829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44830 }
44831 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44832 ecode2 = SWIG_AsVal_int(obj1, &val2);
44833 if (!SWIG_IsOK(ecode2)) {
44834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44835 }
44836 arg2 = static_cast< int >(val2);
44837 {
44838 PyThreadState* __tstate = wxPyBeginAllowThreads();
44839 (arg1)->Select(arg2);
44840 wxPyEndAllowThreads(__tstate);
44841 if (PyErr_Occurred()) SWIG_fail;
44842 }
44843 resultobj = SWIG_Py_Void();
44844 return resultobj;
44845 fail:
44846 return NULL;
44847 }
44848
44849
44850 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44851 PyObject *obj;
44852 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44853 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44854 return SWIG_Py_Void();
44855 }
44856
44857 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44858 PyObject *obj;
44859 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44860 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44861 return SWIG_Py_Void();
44862 }
44863
44864 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44865 PyObject *resultobj = 0;
44866 wxSizerItem *result = 0 ;
44867
44868 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44869 {
44870 PyThreadState* __tstate = wxPyBeginAllowThreads();
44871 result = (wxSizerItem *)new wxSizerItem();
44872 wxPyEndAllowThreads(__tstate);
44873 if (PyErr_Occurred()) SWIG_fail;
44874 }
44875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44876 return resultobj;
44877 fail:
44878 return NULL;
44879 }
44880
44881
44882 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44883 PyObject *resultobj = 0;
44884 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44885 void *argp1 = 0 ;
44886 int res1 = 0 ;
44887 PyObject *swig_obj[1] ;
44888
44889 if (!args) SWIG_fail;
44890 swig_obj[0] = args;
44891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44892 if (!SWIG_IsOK(res1)) {
44893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44894 }
44895 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44896 {
44897 PyThreadState* __tstate = wxPyBeginAllowThreads();
44898 delete arg1;
44899
44900 wxPyEndAllowThreads(__tstate);
44901 if (PyErr_Occurred()) SWIG_fail;
44902 }
44903 resultobj = SWIG_Py_Void();
44904 return resultobj;
44905 fail:
44906 return NULL;
44907 }
44908
44909
44910 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44911 PyObject *resultobj = 0;
44912 wxWindow *arg1 = (wxWindow *) 0 ;
44913 int arg2 ;
44914 int arg3 ;
44915 int arg4 ;
44916 PyObject *arg5 = (PyObject *) NULL ;
44917 wxSizerItem *result = 0 ;
44918 void *argp1 = 0 ;
44919 int res1 = 0 ;
44920 int val2 ;
44921 int ecode2 = 0 ;
44922 int val3 ;
44923 int ecode3 = 0 ;
44924 int val4 ;
44925 int ecode4 = 0 ;
44926 PyObject * obj0 = 0 ;
44927 PyObject * obj1 = 0 ;
44928 PyObject * obj2 = 0 ;
44929 PyObject * obj3 = 0 ;
44930 PyObject * obj4 = 0 ;
44931 char * kwnames[] = {
44932 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44933 };
44934
44935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44937 if (!SWIG_IsOK(res1)) {
44938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44939 }
44940 arg1 = reinterpret_cast< wxWindow * >(argp1);
44941 ecode2 = SWIG_AsVal_int(obj1, &val2);
44942 if (!SWIG_IsOK(ecode2)) {
44943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44944 }
44945 arg2 = static_cast< int >(val2);
44946 ecode3 = SWIG_AsVal_int(obj2, &val3);
44947 if (!SWIG_IsOK(ecode3)) {
44948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44949 }
44950 arg3 = static_cast< int >(val3);
44951 ecode4 = SWIG_AsVal_int(obj3, &val4);
44952 if (!SWIG_IsOK(ecode4)) {
44953 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44954 }
44955 arg4 = static_cast< int >(val4);
44956 if (obj4) {
44957 arg5 = obj4;
44958 }
44959 {
44960 PyThreadState* __tstate = wxPyBeginAllowThreads();
44961 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44962 wxPyEndAllowThreads(__tstate);
44963 if (PyErr_Occurred()) SWIG_fail;
44964 }
44965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44966 return resultobj;
44967 fail:
44968 return NULL;
44969 }
44970
44971
44972 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44973 PyObject *resultobj = 0;
44974 int arg1 ;
44975 int arg2 ;
44976 int arg3 ;
44977 int arg4 ;
44978 int arg5 ;
44979 PyObject *arg6 = (PyObject *) NULL ;
44980 wxSizerItem *result = 0 ;
44981 int val1 ;
44982 int ecode1 = 0 ;
44983 int val2 ;
44984 int ecode2 = 0 ;
44985 int val3 ;
44986 int ecode3 = 0 ;
44987 int val4 ;
44988 int ecode4 = 0 ;
44989 int val5 ;
44990 int ecode5 = 0 ;
44991 PyObject * obj0 = 0 ;
44992 PyObject * obj1 = 0 ;
44993 PyObject * obj2 = 0 ;
44994 PyObject * obj3 = 0 ;
44995 PyObject * obj4 = 0 ;
44996 PyObject * obj5 = 0 ;
44997 char * kwnames[] = {
44998 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44999 };
45000
45001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45002 ecode1 = SWIG_AsVal_int(obj0, &val1);
45003 if (!SWIG_IsOK(ecode1)) {
45004 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45005 }
45006 arg1 = static_cast< int >(val1);
45007 ecode2 = SWIG_AsVal_int(obj1, &val2);
45008 if (!SWIG_IsOK(ecode2)) {
45009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45010 }
45011 arg2 = static_cast< int >(val2);
45012 ecode3 = SWIG_AsVal_int(obj2, &val3);
45013 if (!SWIG_IsOK(ecode3)) {
45014 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45015 }
45016 arg3 = static_cast< int >(val3);
45017 ecode4 = SWIG_AsVal_int(obj3, &val4);
45018 if (!SWIG_IsOK(ecode4)) {
45019 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45020 }
45021 arg4 = static_cast< int >(val4);
45022 ecode5 = SWIG_AsVal_int(obj4, &val5);
45023 if (!SWIG_IsOK(ecode5)) {
45024 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45025 }
45026 arg5 = static_cast< int >(val5);
45027 if (obj5) {
45028 arg6 = obj5;
45029 }
45030 {
45031 PyThreadState* __tstate = wxPyBeginAllowThreads();
45032 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45033 wxPyEndAllowThreads(__tstate);
45034 if (PyErr_Occurred()) SWIG_fail;
45035 }
45036 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45037 return resultobj;
45038 fail:
45039 return NULL;
45040 }
45041
45042
45043 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45044 PyObject *resultobj = 0;
45045 wxSizer *arg1 = (wxSizer *) 0 ;
45046 int arg2 ;
45047 int arg3 ;
45048 int arg4 ;
45049 PyObject *arg5 = (PyObject *) NULL ;
45050 wxSizerItem *result = 0 ;
45051 int res1 = 0 ;
45052 int val2 ;
45053 int ecode2 = 0 ;
45054 int val3 ;
45055 int ecode3 = 0 ;
45056 int val4 ;
45057 int ecode4 = 0 ;
45058 PyObject * obj0 = 0 ;
45059 PyObject * obj1 = 0 ;
45060 PyObject * obj2 = 0 ;
45061 PyObject * obj3 = 0 ;
45062 PyObject * obj4 = 0 ;
45063 char * kwnames[] = {
45064 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45065 };
45066
45067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45068 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45069 if (!SWIG_IsOK(res1)) {
45070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45071 }
45072 ecode2 = SWIG_AsVal_int(obj1, &val2);
45073 if (!SWIG_IsOK(ecode2)) {
45074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45075 }
45076 arg2 = static_cast< int >(val2);
45077 ecode3 = SWIG_AsVal_int(obj2, &val3);
45078 if (!SWIG_IsOK(ecode3)) {
45079 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45080 }
45081 arg3 = static_cast< int >(val3);
45082 ecode4 = SWIG_AsVal_int(obj3, &val4);
45083 if (!SWIG_IsOK(ecode4)) {
45084 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45085 }
45086 arg4 = static_cast< int >(val4);
45087 if (obj4) {
45088 arg5 = obj4;
45089 }
45090 {
45091 PyThreadState* __tstate = wxPyBeginAllowThreads();
45092 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45093 wxPyEndAllowThreads(__tstate);
45094 if (PyErr_Occurred()) SWIG_fail;
45095 }
45096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45097 return resultobj;
45098 fail:
45099 return NULL;
45100 }
45101
45102
45103 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45104 PyObject *resultobj = 0;
45105 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45106 void *argp1 = 0 ;
45107 int res1 = 0 ;
45108 PyObject *swig_obj[1] ;
45109
45110 if (!args) SWIG_fail;
45111 swig_obj[0] = args;
45112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45113 if (!SWIG_IsOK(res1)) {
45114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45115 }
45116 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45117 {
45118 PyThreadState* __tstate = wxPyBeginAllowThreads();
45119 (arg1)->DeleteWindows();
45120 wxPyEndAllowThreads(__tstate);
45121 if (PyErr_Occurred()) SWIG_fail;
45122 }
45123 resultobj = SWIG_Py_Void();
45124 return resultobj;
45125 fail:
45126 return NULL;
45127 }
45128
45129
45130 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45131 PyObject *resultobj = 0;
45132 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45133 void *argp1 = 0 ;
45134 int res1 = 0 ;
45135 PyObject *swig_obj[1] ;
45136
45137 if (!args) SWIG_fail;
45138 swig_obj[0] = args;
45139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45140 if (!SWIG_IsOK(res1)) {
45141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45142 }
45143 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45144 {
45145 PyThreadState* __tstate = wxPyBeginAllowThreads();
45146 (arg1)->DetachSizer();
45147 wxPyEndAllowThreads(__tstate);
45148 if (PyErr_Occurred()) SWIG_fail;
45149 }
45150 resultobj = SWIG_Py_Void();
45151 return resultobj;
45152 fail:
45153 return NULL;
45154 }
45155
45156
45157 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45158 PyObject *resultobj = 0;
45159 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45160 wxSize result;
45161 void *argp1 = 0 ;
45162 int res1 = 0 ;
45163 PyObject *swig_obj[1] ;
45164
45165 if (!args) SWIG_fail;
45166 swig_obj[0] = args;
45167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45168 if (!SWIG_IsOK(res1)) {
45169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45170 }
45171 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45172 {
45173 PyThreadState* __tstate = wxPyBeginAllowThreads();
45174 result = (arg1)->GetSize();
45175 wxPyEndAllowThreads(__tstate);
45176 if (PyErr_Occurred()) SWIG_fail;
45177 }
45178 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45179 return resultobj;
45180 fail:
45181 return NULL;
45182 }
45183
45184
45185 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45186 PyObject *resultobj = 0;
45187 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45188 wxSize result;
45189 void *argp1 = 0 ;
45190 int res1 = 0 ;
45191 PyObject *swig_obj[1] ;
45192
45193 if (!args) SWIG_fail;
45194 swig_obj[0] = args;
45195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45196 if (!SWIG_IsOK(res1)) {
45197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45198 }
45199 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45200 {
45201 PyThreadState* __tstate = wxPyBeginAllowThreads();
45202 result = (arg1)->CalcMin();
45203 wxPyEndAllowThreads(__tstate);
45204 if (PyErr_Occurred()) SWIG_fail;
45205 }
45206 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45207 return resultobj;
45208 fail:
45209 return NULL;
45210 }
45211
45212
45213 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45214 PyObject *resultobj = 0;
45215 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45216 wxPoint *arg2 = 0 ;
45217 wxSize *arg3 = 0 ;
45218 void *argp1 = 0 ;
45219 int res1 = 0 ;
45220 wxPoint temp2 ;
45221 wxSize temp3 ;
45222 PyObject * obj0 = 0 ;
45223 PyObject * obj1 = 0 ;
45224 PyObject * obj2 = 0 ;
45225 char * kwnames[] = {
45226 (char *) "self",(char *) "pos",(char *) "size", NULL
45227 };
45228
45229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45231 if (!SWIG_IsOK(res1)) {
45232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45233 }
45234 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45235 {
45236 arg2 = &temp2;
45237 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45238 }
45239 {
45240 arg3 = &temp3;
45241 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45242 }
45243 {
45244 PyThreadState* __tstate = wxPyBeginAllowThreads();
45245 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45246 wxPyEndAllowThreads(__tstate);
45247 if (PyErr_Occurred()) SWIG_fail;
45248 }
45249 resultobj = SWIG_Py_Void();
45250 return resultobj;
45251 fail:
45252 return NULL;
45253 }
45254
45255
45256 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45257 PyObject *resultobj = 0;
45258 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45259 wxSize result;
45260 void *argp1 = 0 ;
45261 int res1 = 0 ;
45262 PyObject *swig_obj[1] ;
45263
45264 if (!args) SWIG_fail;
45265 swig_obj[0] = args;
45266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45267 if (!SWIG_IsOK(res1)) {
45268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45269 }
45270 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45271 {
45272 PyThreadState* __tstate = wxPyBeginAllowThreads();
45273 result = (arg1)->GetMinSize();
45274 wxPyEndAllowThreads(__tstate);
45275 if (PyErr_Occurred()) SWIG_fail;
45276 }
45277 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45278 return resultobj;
45279 fail:
45280 return NULL;
45281 }
45282
45283
45284 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45285 PyObject *resultobj = 0;
45286 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45287 wxSize result;
45288 void *argp1 = 0 ;
45289 int res1 = 0 ;
45290 PyObject *swig_obj[1] ;
45291
45292 if (!args) SWIG_fail;
45293 swig_obj[0] = args;
45294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45295 if (!SWIG_IsOK(res1)) {
45296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45297 }
45298 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45299 {
45300 PyThreadState* __tstate = wxPyBeginAllowThreads();
45301 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45302 wxPyEndAllowThreads(__tstate);
45303 if (PyErr_Occurred()) SWIG_fail;
45304 }
45305 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45306 return resultobj;
45307 fail:
45308 return NULL;
45309 }
45310
45311
45312 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45313 PyObject *resultobj = 0;
45314 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45315 int arg2 ;
45316 int arg3 ;
45317 void *argp1 = 0 ;
45318 int res1 = 0 ;
45319 int val2 ;
45320 int ecode2 = 0 ;
45321 int val3 ;
45322 int ecode3 = 0 ;
45323 PyObject * obj0 = 0 ;
45324 PyObject * obj1 = 0 ;
45325 PyObject * obj2 = 0 ;
45326 char * kwnames[] = {
45327 (char *) "self",(char *) "x",(char *) "y", NULL
45328 };
45329
45330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45332 if (!SWIG_IsOK(res1)) {
45333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45334 }
45335 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45336 ecode2 = SWIG_AsVal_int(obj1, &val2);
45337 if (!SWIG_IsOK(ecode2)) {
45338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45339 }
45340 arg2 = static_cast< int >(val2);
45341 ecode3 = SWIG_AsVal_int(obj2, &val3);
45342 if (!SWIG_IsOK(ecode3)) {
45343 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45344 }
45345 arg3 = static_cast< int >(val3);
45346 {
45347 PyThreadState* __tstate = wxPyBeginAllowThreads();
45348 (arg1)->SetInitSize(arg2,arg3);
45349 wxPyEndAllowThreads(__tstate);
45350 if (PyErr_Occurred()) SWIG_fail;
45351 }
45352 resultobj = SWIG_Py_Void();
45353 return resultobj;
45354 fail:
45355 return NULL;
45356 }
45357
45358
45359 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45360 PyObject *resultobj = 0;
45361 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45362 int arg2 ;
45363 int arg3 ;
45364 void *argp1 = 0 ;
45365 int res1 = 0 ;
45366 int val2 ;
45367 int ecode2 = 0 ;
45368 int val3 ;
45369 int ecode3 = 0 ;
45370 PyObject * obj0 = 0 ;
45371 PyObject * obj1 = 0 ;
45372 PyObject * obj2 = 0 ;
45373 char * kwnames[] = {
45374 (char *) "self",(char *) "width",(char *) "height", NULL
45375 };
45376
45377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45379 if (!SWIG_IsOK(res1)) {
45380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45381 }
45382 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45383 ecode2 = SWIG_AsVal_int(obj1, &val2);
45384 if (!SWIG_IsOK(ecode2)) {
45385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45386 }
45387 arg2 = static_cast< int >(val2);
45388 ecode3 = SWIG_AsVal_int(obj2, &val3);
45389 if (!SWIG_IsOK(ecode3)) {
45390 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45391 }
45392 arg3 = static_cast< int >(val3);
45393 {
45394 PyThreadState* __tstate = wxPyBeginAllowThreads();
45395 (arg1)->SetRatio(arg2,arg3);
45396 wxPyEndAllowThreads(__tstate);
45397 if (PyErr_Occurred()) SWIG_fail;
45398 }
45399 resultobj = SWIG_Py_Void();
45400 return resultobj;
45401 fail:
45402 return NULL;
45403 }
45404
45405
45406 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45407 PyObject *resultobj = 0;
45408 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45409 wxSize *arg2 = 0 ;
45410 void *argp1 = 0 ;
45411 int res1 = 0 ;
45412 wxSize temp2 ;
45413 PyObject * obj0 = 0 ;
45414 PyObject * obj1 = 0 ;
45415 char * kwnames[] = {
45416 (char *) "self",(char *) "size", NULL
45417 };
45418
45419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45421 if (!SWIG_IsOK(res1)) {
45422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45423 }
45424 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45425 {
45426 arg2 = &temp2;
45427 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45428 }
45429 {
45430 PyThreadState* __tstate = wxPyBeginAllowThreads();
45431 (arg1)->SetRatio((wxSize const &)*arg2);
45432 wxPyEndAllowThreads(__tstate);
45433 if (PyErr_Occurred()) SWIG_fail;
45434 }
45435 resultobj = SWIG_Py_Void();
45436 return resultobj;
45437 fail:
45438 return NULL;
45439 }
45440
45441
45442 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45443 PyObject *resultobj = 0;
45444 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45445 float arg2 ;
45446 void *argp1 = 0 ;
45447 int res1 = 0 ;
45448 float val2 ;
45449 int ecode2 = 0 ;
45450 PyObject * obj0 = 0 ;
45451 PyObject * obj1 = 0 ;
45452 char * kwnames[] = {
45453 (char *) "self",(char *) "ratio", NULL
45454 };
45455
45456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45458 if (!SWIG_IsOK(res1)) {
45459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45460 }
45461 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45462 ecode2 = SWIG_AsVal_float(obj1, &val2);
45463 if (!SWIG_IsOK(ecode2)) {
45464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45465 }
45466 arg2 = static_cast< float >(val2);
45467 {
45468 PyThreadState* __tstate = wxPyBeginAllowThreads();
45469 (arg1)->SetRatio(arg2);
45470 wxPyEndAllowThreads(__tstate);
45471 if (PyErr_Occurred()) SWIG_fail;
45472 }
45473 resultobj = SWIG_Py_Void();
45474 return resultobj;
45475 fail:
45476 return NULL;
45477 }
45478
45479
45480 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45481 PyObject *resultobj = 0;
45482 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45483 float result;
45484 void *argp1 = 0 ;
45485 int res1 = 0 ;
45486 PyObject *swig_obj[1] ;
45487
45488 if (!args) SWIG_fail;
45489 swig_obj[0] = args;
45490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45491 if (!SWIG_IsOK(res1)) {
45492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45493 }
45494 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45495 {
45496 PyThreadState* __tstate = wxPyBeginAllowThreads();
45497 result = (float)(arg1)->GetRatio();
45498 wxPyEndAllowThreads(__tstate);
45499 if (PyErr_Occurred()) SWIG_fail;
45500 }
45501 resultobj = SWIG_From_float(static_cast< float >(result));
45502 return resultobj;
45503 fail:
45504 return NULL;
45505 }
45506
45507
45508 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45509 PyObject *resultobj = 0;
45510 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45511 wxRect result;
45512 void *argp1 = 0 ;
45513 int res1 = 0 ;
45514 PyObject *swig_obj[1] ;
45515
45516 if (!args) SWIG_fail;
45517 swig_obj[0] = args;
45518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45519 if (!SWIG_IsOK(res1)) {
45520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45521 }
45522 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45523 {
45524 PyThreadState* __tstate = wxPyBeginAllowThreads();
45525 result = (arg1)->GetRect();
45526 wxPyEndAllowThreads(__tstate);
45527 if (PyErr_Occurred()) SWIG_fail;
45528 }
45529 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45530 return resultobj;
45531 fail:
45532 return NULL;
45533 }
45534
45535
45536 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45537 PyObject *resultobj = 0;
45538 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45539 bool result;
45540 void *argp1 = 0 ;
45541 int res1 = 0 ;
45542 PyObject *swig_obj[1] ;
45543
45544 if (!args) SWIG_fail;
45545 swig_obj[0] = args;
45546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45547 if (!SWIG_IsOK(res1)) {
45548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45549 }
45550 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45551 {
45552 PyThreadState* __tstate = wxPyBeginAllowThreads();
45553 result = (bool)(arg1)->IsWindow();
45554 wxPyEndAllowThreads(__tstate);
45555 if (PyErr_Occurred()) SWIG_fail;
45556 }
45557 {
45558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45559 }
45560 return resultobj;
45561 fail:
45562 return NULL;
45563 }
45564
45565
45566 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45567 PyObject *resultobj = 0;
45568 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45569 bool result;
45570 void *argp1 = 0 ;
45571 int res1 = 0 ;
45572 PyObject *swig_obj[1] ;
45573
45574 if (!args) SWIG_fail;
45575 swig_obj[0] = args;
45576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45577 if (!SWIG_IsOK(res1)) {
45578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45579 }
45580 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45581 {
45582 PyThreadState* __tstate = wxPyBeginAllowThreads();
45583 result = (bool)(arg1)->IsSizer();
45584 wxPyEndAllowThreads(__tstate);
45585 if (PyErr_Occurred()) SWIG_fail;
45586 }
45587 {
45588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45589 }
45590 return resultobj;
45591 fail:
45592 return NULL;
45593 }
45594
45595
45596 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45597 PyObject *resultobj = 0;
45598 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45599 bool result;
45600 void *argp1 = 0 ;
45601 int res1 = 0 ;
45602 PyObject *swig_obj[1] ;
45603
45604 if (!args) SWIG_fail;
45605 swig_obj[0] = args;
45606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45607 if (!SWIG_IsOK(res1)) {
45608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45609 }
45610 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45611 {
45612 PyThreadState* __tstate = wxPyBeginAllowThreads();
45613 result = (bool)(arg1)->IsSpacer();
45614 wxPyEndAllowThreads(__tstate);
45615 if (PyErr_Occurred()) SWIG_fail;
45616 }
45617 {
45618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45619 }
45620 return resultobj;
45621 fail:
45622 return NULL;
45623 }
45624
45625
45626 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45627 PyObject *resultobj = 0;
45628 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45629 int arg2 ;
45630 void *argp1 = 0 ;
45631 int res1 = 0 ;
45632 int val2 ;
45633 int ecode2 = 0 ;
45634 PyObject * obj0 = 0 ;
45635 PyObject * obj1 = 0 ;
45636 char * kwnames[] = {
45637 (char *) "self",(char *) "proportion", NULL
45638 };
45639
45640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45642 if (!SWIG_IsOK(res1)) {
45643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45644 }
45645 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45646 ecode2 = SWIG_AsVal_int(obj1, &val2);
45647 if (!SWIG_IsOK(ecode2)) {
45648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45649 }
45650 arg2 = static_cast< int >(val2);
45651 {
45652 PyThreadState* __tstate = wxPyBeginAllowThreads();
45653 (arg1)->SetProportion(arg2);
45654 wxPyEndAllowThreads(__tstate);
45655 if (PyErr_Occurred()) SWIG_fail;
45656 }
45657 resultobj = SWIG_Py_Void();
45658 return resultobj;
45659 fail:
45660 return NULL;
45661 }
45662
45663
45664 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45665 PyObject *resultobj = 0;
45666 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45667 int result;
45668 void *argp1 = 0 ;
45669 int res1 = 0 ;
45670 PyObject *swig_obj[1] ;
45671
45672 if (!args) SWIG_fail;
45673 swig_obj[0] = args;
45674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45675 if (!SWIG_IsOK(res1)) {
45676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45677 }
45678 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45679 {
45680 PyThreadState* __tstate = wxPyBeginAllowThreads();
45681 result = (int)(arg1)->GetProportion();
45682 wxPyEndAllowThreads(__tstate);
45683 if (PyErr_Occurred()) SWIG_fail;
45684 }
45685 resultobj = SWIG_From_int(static_cast< int >(result));
45686 return resultobj;
45687 fail:
45688 return NULL;
45689 }
45690
45691
45692 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45693 PyObject *resultobj = 0;
45694 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45695 int arg2 ;
45696 void *argp1 = 0 ;
45697 int res1 = 0 ;
45698 int val2 ;
45699 int ecode2 = 0 ;
45700 PyObject * obj0 = 0 ;
45701 PyObject * obj1 = 0 ;
45702 char * kwnames[] = {
45703 (char *) "self",(char *) "flag", NULL
45704 };
45705
45706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45708 if (!SWIG_IsOK(res1)) {
45709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45710 }
45711 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45712 ecode2 = SWIG_AsVal_int(obj1, &val2);
45713 if (!SWIG_IsOK(ecode2)) {
45714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45715 }
45716 arg2 = static_cast< int >(val2);
45717 {
45718 PyThreadState* __tstate = wxPyBeginAllowThreads();
45719 (arg1)->SetFlag(arg2);
45720 wxPyEndAllowThreads(__tstate);
45721 if (PyErr_Occurred()) SWIG_fail;
45722 }
45723 resultobj = SWIG_Py_Void();
45724 return resultobj;
45725 fail:
45726 return NULL;
45727 }
45728
45729
45730 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45731 PyObject *resultobj = 0;
45732 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45733 int result;
45734 void *argp1 = 0 ;
45735 int res1 = 0 ;
45736 PyObject *swig_obj[1] ;
45737
45738 if (!args) SWIG_fail;
45739 swig_obj[0] = args;
45740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45741 if (!SWIG_IsOK(res1)) {
45742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45743 }
45744 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45745 {
45746 PyThreadState* __tstate = wxPyBeginAllowThreads();
45747 result = (int)(arg1)->GetFlag();
45748 wxPyEndAllowThreads(__tstate);
45749 if (PyErr_Occurred()) SWIG_fail;
45750 }
45751 resultobj = SWIG_From_int(static_cast< int >(result));
45752 return resultobj;
45753 fail:
45754 return NULL;
45755 }
45756
45757
45758 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45759 PyObject *resultobj = 0;
45760 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45761 int arg2 ;
45762 void *argp1 = 0 ;
45763 int res1 = 0 ;
45764 int val2 ;
45765 int ecode2 = 0 ;
45766 PyObject * obj0 = 0 ;
45767 PyObject * obj1 = 0 ;
45768 char * kwnames[] = {
45769 (char *) "self",(char *) "border", NULL
45770 };
45771
45772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45774 if (!SWIG_IsOK(res1)) {
45775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45776 }
45777 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45778 ecode2 = SWIG_AsVal_int(obj1, &val2);
45779 if (!SWIG_IsOK(ecode2)) {
45780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45781 }
45782 arg2 = static_cast< int >(val2);
45783 {
45784 PyThreadState* __tstate = wxPyBeginAllowThreads();
45785 (arg1)->SetBorder(arg2);
45786 wxPyEndAllowThreads(__tstate);
45787 if (PyErr_Occurred()) SWIG_fail;
45788 }
45789 resultobj = SWIG_Py_Void();
45790 return resultobj;
45791 fail:
45792 return NULL;
45793 }
45794
45795
45796 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45797 PyObject *resultobj = 0;
45798 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45799 int result;
45800 void *argp1 = 0 ;
45801 int res1 = 0 ;
45802 PyObject *swig_obj[1] ;
45803
45804 if (!args) SWIG_fail;
45805 swig_obj[0] = args;
45806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45807 if (!SWIG_IsOK(res1)) {
45808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45809 }
45810 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45811 {
45812 PyThreadState* __tstate = wxPyBeginAllowThreads();
45813 result = (int)(arg1)->GetBorder();
45814 wxPyEndAllowThreads(__tstate);
45815 if (PyErr_Occurred()) SWIG_fail;
45816 }
45817 resultobj = SWIG_From_int(static_cast< int >(result));
45818 return resultobj;
45819 fail:
45820 return NULL;
45821 }
45822
45823
45824 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45825 PyObject *resultobj = 0;
45826 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45827 wxWindow *result = 0 ;
45828 void *argp1 = 0 ;
45829 int res1 = 0 ;
45830 PyObject *swig_obj[1] ;
45831
45832 if (!args) SWIG_fail;
45833 swig_obj[0] = args;
45834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45835 if (!SWIG_IsOK(res1)) {
45836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45837 }
45838 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45839 {
45840 PyThreadState* __tstate = wxPyBeginAllowThreads();
45841 result = (wxWindow *)(arg1)->GetWindow();
45842 wxPyEndAllowThreads(__tstate);
45843 if (PyErr_Occurred()) SWIG_fail;
45844 }
45845 {
45846 resultobj = wxPyMake_wxObject(result, 0);
45847 }
45848 return resultobj;
45849 fail:
45850 return NULL;
45851 }
45852
45853
45854 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45855 PyObject *resultobj = 0;
45856 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45857 wxWindow *arg2 = (wxWindow *) 0 ;
45858 void *argp1 = 0 ;
45859 int res1 = 0 ;
45860 void *argp2 = 0 ;
45861 int res2 = 0 ;
45862 PyObject * obj0 = 0 ;
45863 PyObject * obj1 = 0 ;
45864 char * kwnames[] = {
45865 (char *) "self",(char *) "window", NULL
45866 };
45867
45868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45870 if (!SWIG_IsOK(res1)) {
45871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45872 }
45873 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45874 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45875 if (!SWIG_IsOK(res2)) {
45876 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45877 }
45878 arg2 = reinterpret_cast< wxWindow * >(argp2);
45879 {
45880 PyThreadState* __tstate = wxPyBeginAllowThreads();
45881 (arg1)->SetWindow(arg2);
45882 wxPyEndAllowThreads(__tstate);
45883 if (PyErr_Occurred()) SWIG_fail;
45884 }
45885 resultobj = SWIG_Py_Void();
45886 return resultobj;
45887 fail:
45888 return NULL;
45889 }
45890
45891
45892 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45893 PyObject *resultobj = 0;
45894 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45895 wxSizer *result = 0 ;
45896 void *argp1 = 0 ;
45897 int res1 = 0 ;
45898 PyObject *swig_obj[1] ;
45899
45900 if (!args) SWIG_fail;
45901 swig_obj[0] = args;
45902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45903 if (!SWIG_IsOK(res1)) {
45904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45905 }
45906 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45907 {
45908 PyThreadState* __tstate = wxPyBeginAllowThreads();
45909 result = (wxSizer *)(arg1)->GetSizer();
45910 wxPyEndAllowThreads(__tstate);
45911 if (PyErr_Occurred()) SWIG_fail;
45912 }
45913 {
45914 resultobj = wxPyMake_wxObject(result, (bool)0);
45915 }
45916 return resultobj;
45917 fail:
45918 return NULL;
45919 }
45920
45921
45922 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45923 PyObject *resultobj = 0;
45924 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45925 wxSizer *arg2 = (wxSizer *) 0 ;
45926 void *argp1 = 0 ;
45927 int res1 = 0 ;
45928 int res2 = 0 ;
45929 PyObject * obj0 = 0 ;
45930 PyObject * obj1 = 0 ;
45931 char * kwnames[] = {
45932 (char *) "self",(char *) "sizer", NULL
45933 };
45934
45935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45937 if (!SWIG_IsOK(res1)) {
45938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45939 }
45940 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45941 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45942 if (!SWIG_IsOK(res2)) {
45943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45944 }
45945 {
45946 PyThreadState* __tstate = wxPyBeginAllowThreads();
45947 (arg1)->SetSizer(arg2);
45948 wxPyEndAllowThreads(__tstate);
45949 if (PyErr_Occurred()) SWIG_fail;
45950 }
45951 resultobj = SWIG_Py_Void();
45952 return resultobj;
45953 fail:
45954 return NULL;
45955 }
45956
45957
45958 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45959 PyObject *resultobj = 0;
45960 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45961 wxSize *result = 0 ;
45962 void *argp1 = 0 ;
45963 int res1 = 0 ;
45964 PyObject *swig_obj[1] ;
45965
45966 if (!args) SWIG_fail;
45967 swig_obj[0] = args;
45968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45969 if (!SWIG_IsOK(res1)) {
45970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45971 }
45972 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45973 {
45974 PyThreadState* __tstate = wxPyBeginAllowThreads();
45975 {
45976 wxSize const &_result_ref = (arg1)->GetSpacer();
45977 result = (wxSize *) &_result_ref;
45978 }
45979 wxPyEndAllowThreads(__tstate);
45980 if (PyErr_Occurred()) SWIG_fail;
45981 }
45982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45983 return resultobj;
45984 fail:
45985 return NULL;
45986 }
45987
45988
45989 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45990 PyObject *resultobj = 0;
45991 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45992 wxSize *arg2 = 0 ;
45993 void *argp1 = 0 ;
45994 int res1 = 0 ;
45995 wxSize temp2 ;
45996 PyObject * obj0 = 0 ;
45997 PyObject * obj1 = 0 ;
45998 char * kwnames[] = {
45999 (char *) "self",(char *) "size", NULL
46000 };
46001
46002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46004 if (!SWIG_IsOK(res1)) {
46005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46006 }
46007 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46008 {
46009 arg2 = &temp2;
46010 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46011 }
46012 {
46013 PyThreadState* __tstate = wxPyBeginAllowThreads();
46014 (arg1)->SetSpacer((wxSize const &)*arg2);
46015 wxPyEndAllowThreads(__tstate);
46016 if (PyErr_Occurred()) SWIG_fail;
46017 }
46018 resultobj = SWIG_Py_Void();
46019 return resultobj;
46020 fail:
46021 return NULL;
46022 }
46023
46024
46025 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46026 PyObject *resultobj = 0;
46027 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46028 bool arg2 ;
46029 void *argp1 = 0 ;
46030 int res1 = 0 ;
46031 bool val2 ;
46032 int ecode2 = 0 ;
46033 PyObject * obj0 = 0 ;
46034 PyObject * obj1 = 0 ;
46035 char * kwnames[] = {
46036 (char *) "self",(char *) "show", NULL
46037 };
46038
46039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46041 if (!SWIG_IsOK(res1)) {
46042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46043 }
46044 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46045 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46046 if (!SWIG_IsOK(ecode2)) {
46047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46048 }
46049 arg2 = static_cast< bool >(val2);
46050 {
46051 PyThreadState* __tstate = wxPyBeginAllowThreads();
46052 (arg1)->Show(arg2);
46053 wxPyEndAllowThreads(__tstate);
46054 if (PyErr_Occurred()) SWIG_fail;
46055 }
46056 resultobj = SWIG_Py_Void();
46057 return resultobj;
46058 fail:
46059 return NULL;
46060 }
46061
46062
46063 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46064 PyObject *resultobj = 0;
46065 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46066 bool result;
46067 void *argp1 = 0 ;
46068 int res1 = 0 ;
46069 PyObject *swig_obj[1] ;
46070
46071 if (!args) SWIG_fail;
46072 swig_obj[0] = args;
46073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46074 if (!SWIG_IsOK(res1)) {
46075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46076 }
46077 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46078 {
46079 PyThreadState* __tstate = wxPyBeginAllowThreads();
46080 result = (bool)(arg1)->IsShown();
46081 wxPyEndAllowThreads(__tstate);
46082 if (PyErr_Occurred()) SWIG_fail;
46083 }
46084 {
46085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46086 }
46087 return resultobj;
46088 fail:
46089 return NULL;
46090 }
46091
46092
46093 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46094 PyObject *resultobj = 0;
46095 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46096 wxPoint result;
46097 void *argp1 = 0 ;
46098 int res1 = 0 ;
46099 PyObject *swig_obj[1] ;
46100
46101 if (!args) SWIG_fail;
46102 swig_obj[0] = args;
46103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46104 if (!SWIG_IsOK(res1)) {
46105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46106 }
46107 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46108 {
46109 PyThreadState* __tstate = wxPyBeginAllowThreads();
46110 result = (arg1)->GetPosition();
46111 wxPyEndAllowThreads(__tstate);
46112 if (PyErr_Occurred()) SWIG_fail;
46113 }
46114 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46115 return resultobj;
46116 fail:
46117 return NULL;
46118 }
46119
46120
46121 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46122 PyObject *resultobj = 0;
46123 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46124 PyObject *result = 0 ;
46125 void *argp1 = 0 ;
46126 int res1 = 0 ;
46127 PyObject *swig_obj[1] ;
46128
46129 if (!args) SWIG_fail;
46130 swig_obj[0] = args;
46131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46132 if (!SWIG_IsOK(res1)) {
46133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46134 }
46135 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46136 {
46137 PyThreadState* __tstate = wxPyBeginAllowThreads();
46138 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46139 wxPyEndAllowThreads(__tstate);
46140 if (PyErr_Occurred()) SWIG_fail;
46141 }
46142 resultobj = result;
46143 return resultobj;
46144 fail:
46145 return NULL;
46146 }
46147
46148
46149 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46150 PyObject *resultobj = 0;
46151 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46152 PyObject *arg2 = (PyObject *) 0 ;
46153 void *argp1 = 0 ;
46154 int res1 = 0 ;
46155 PyObject * obj0 = 0 ;
46156 PyObject * obj1 = 0 ;
46157 char * kwnames[] = {
46158 (char *) "self",(char *) "userData", NULL
46159 };
46160
46161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46163 if (!SWIG_IsOK(res1)) {
46164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46165 }
46166 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46167 arg2 = obj1;
46168 {
46169 PyThreadState* __tstate = wxPyBeginAllowThreads();
46170 wxSizerItem_SetUserData(arg1,arg2);
46171 wxPyEndAllowThreads(__tstate);
46172 if (PyErr_Occurred()) SWIG_fail;
46173 }
46174 resultobj = SWIG_Py_Void();
46175 return resultobj;
46176 fail:
46177 return NULL;
46178 }
46179
46180
46181 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46182 PyObject *obj;
46183 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46184 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46185 return SWIG_Py_Void();
46186 }
46187
46188 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46189 return SWIG_Python_InitShadowInstance(args);
46190 }
46191
46192 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46193 PyObject *resultobj = 0;
46194 wxSizer *arg1 = (wxSizer *) 0 ;
46195 void *argp1 = 0 ;
46196 int res1 = 0 ;
46197 PyObject *swig_obj[1] ;
46198
46199 if (!args) SWIG_fail;
46200 swig_obj[0] = args;
46201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46202 if (!SWIG_IsOK(res1)) {
46203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46204 }
46205 arg1 = reinterpret_cast< wxSizer * >(argp1);
46206 {
46207 PyThreadState* __tstate = wxPyBeginAllowThreads();
46208 delete arg1;
46209
46210 wxPyEndAllowThreads(__tstate);
46211 if (PyErr_Occurred()) SWIG_fail;
46212 }
46213 resultobj = SWIG_Py_Void();
46214 return resultobj;
46215 fail:
46216 return NULL;
46217 }
46218
46219
46220 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46221 PyObject *resultobj = 0;
46222 wxSizer *arg1 = (wxSizer *) 0 ;
46223 PyObject *arg2 = (PyObject *) 0 ;
46224 void *argp1 = 0 ;
46225 int res1 = 0 ;
46226 PyObject * obj0 = 0 ;
46227 PyObject * obj1 = 0 ;
46228 char * kwnames[] = {
46229 (char *) "self",(char *) "_self", NULL
46230 };
46231
46232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46234 if (!SWIG_IsOK(res1)) {
46235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46236 }
46237 arg1 = reinterpret_cast< wxSizer * >(argp1);
46238 arg2 = obj1;
46239 {
46240 PyThreadState* __tstate = wxPyBeginAllowThreads();
46241 wxSizer__setOORInfo(arg1,arg2);
46242 wxPyEndAllowThreads(__tstate);
46243 if (PyErr_Occurred()) SWIG_fail;
46244 }
46245 resultobj = SWIG_Py_Void();
46246 return resultobj;
46247 fail:
46248 return NULL;
46249 }
46250
46251
46252 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46253 PyObject *resultobj = 0;
46254 wxSizer *arg1 = (wxSizer *) 0 ;
46255 PyObject *arg2 = (PyObject *) 0 ;
46256 int arg3 = (int) 0 ;
46257 int arg4 = (int) 0 ;
46258 int arg5 = (int) 0 ;
46259 PyObject *arg6 = (PyObject *) NULL ;
46260 wxSizerItem *result = 0 ;
46261 void *argp1 = 0 ;
46262 int res1 = 0 ;
46263 int val3 ;
46264 int ecode3 = 0 ;
46265 int val4 ;
46266 int ecode4 = 0 ;
46267 int val5 ;
46268 int ecode5 = 0 ;
46269 PyObject * obj0 = 0 ;
46270 PyObject * obj1 = 0 ;
46271 PyObject * obj2 = 0 ;
46272 PyObject * obj3 = 0 ;
46273 PyObject * obj4 = 0 ;
46274 PyObject * obj5 = 0 ;
46275 char * kwnames[] = {
46276 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46277 };
46278
46279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46281 if (!SWIG_IsOK(res1)) {
46282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46283 }
46284 arg1 = reinterpret_cast< wxSizer * >(argp1);
46285 arg2 = obj1;
46286 if (obj2) {
46287 ecode3 = SWIG_AsVal_int(obj2, &val3);
46288 if (!SWIG_IsOK(ecode3)) {
46289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46290 }
46291 arg3 = static_cast< int >(val3);
46292 }
46293 if (obj3) {
46294 ecode4 = SWIG_AsVal_int(obj3, &val4);
46295 if (!SWIG_IsOK(ecode4)) {
46296 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46297 }
46298 arg4 = static_cast< int >(val4);
46299 }
46300 if (obj4) {
46301 ecode5 = SWIG_AsVal_int(obj4, &val5);
46302 if (!SWIG_IsOK(ecode5)) {
46303 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46304 }
46305 arg5 = static_cast< int >(val5);
46306 }
46307 if (obj5) {
46308 arg6 = obj5;
46309 }
46310 {
46311 PyThreadState* __tstate = wxPyBeginAllowThreads();
46312 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46313 wxPyEndAllowThreads(__tstate);
46314 if (PyErr_Occurred()) SWIG_fail;
46315 }
46316 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46317 return resultobj;
46318 fail:
46319 return NULL;
46320 }
46321
46322
46323 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46324 PyObject *resultobj = 0;
46325 wxSizer *arg1 = (wxSizer *) 0 ;
46326 int arg2 ;
46327 PyObject *arg3 = (PyObject *) 0 ;
46328 int arg4 = (int) 0 ;
46329 int arg5 = (int) 0 ;
46330 int arg6 = (int) 0 ;
46331 PyObject *arg7 = (PyObject *) NULL ;
46332 wxSizerItem *result = 0 ;
46333 void *argp1 = 0 ;
46334 int res1 = 0 ;
46335 int val2 ;
46336 int ecode2 = 0 ;
46337 int val4 ;
46338 int ecode4 = 0 ;
46339 int val5 ;
46340 int ecode5 = 0 ;
46341 int val6 ;
46342 int ecode6 = 0 ;
46343 PyObject * obj0 = 0 ;
46344 PyObject * obj1 = 0 ;
46345 PyObject * obj2 = 0 ;
46346 PyObject * obj3 = 0 ;
46347 PyObject * obj4 = 0 ;
46348 PyObject * obj5 = 0 ;
46349 PyObject * obj6 = 0 ;
46350 char * kwnames[] = {
46351 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46352 };
46353
46354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46356 if (!SWIG_IsOK(res1)) {
46357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46358 }
46359 arg1 = reinterpret_cast< wxSizer * >(argp1);
46360 ecode2 = SWIG_AsVal_int(obj1, &val2);
46361 if (!SWIG_IsOK(ecode2)) {
46362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46363 }
46364 arg2 = static_cast< int >(val2);
46365 arg3 = obj2;
46366 if (obj3) {
46367 ecode4 = SWIG_AsVal_int(obj3, &val4);
46368 if (!SWIG_IsOK(ecode4)) {
46369 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46370 }
46371 arg4 = static_cast< int >(val4);
46372 }
46373 if (obj4) {
46374 ecode5 = SWIG_AsVal_int(obj4, &val5);
46375 if (!SWIG_IsOK(ecode5)) {
46376 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46377 }
46378 arg5 = static_cast< int >(val5);
46379 }
46380 if (obj5) {
46381 ecode6 = SWIG_AsVal_int(obj5, &val6);
46382 if (!SWIG_IsOK(ecode6)) {
46383 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46384 }
46385 arg6 = static_cast< int >(val6);
46386 }
46387 if (obj6) {
46388 arg7 = obj6;
46389 }
46390 {
46391 PyThreadState* __tstate = wxPyBeginAllowThreads();
46392 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46393 wxPyEndAllowThreads(__tstate);
46394 if (PyErr_Occurred()) SWIG_fail;
46395 }
46396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46397 return resultobj;
46398 fail:
46399 return NULL;
46400 }
46401
46402
46403 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46404 PyObject *resultobj = 0;
46405 wxSizer *arg1 = (wxSizer *) 0 ;
46406 PyObject *arg2 = (PyObject *) 0 ;
46407 int arg3 = (int) 0 ;
46408 int arg4 = (int) 0 ;
46409 int arg5 = (int) 0 ;
46410 PyObject *arg6 = (PyObject *) NULL ;
46411 wxSizerItem *result = 0 ;
46412 void *argp1 = 0 ;
46413 int res1 = 0 ;
46414 int val3 ;
46415 int ecode3 = 0 ;
46416 int val4 ;
46417 int ecode4 = 0 ;
46418 int val5 ;
46419 int ecode5 = 0 ;
46420 PyObject * obj0 = 0 ;
46421 PyObject * obj1 = 0 ;
46422 PyObject * obj2 = 0 ;
46423 PyObject * obj3 = 0 ;
46424 PyObject * obj4 = 0 ;
46425 PyObject * obj5 = 0 ;
46426 char * kwnames[] = {
46427 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46428 };
46429
46430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46432 if (!SWIG_IsOK(res1)) {
46433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46434 }
46435 arg1 = reinterpret_cast< wxSizer * >(argp1);
46436 arg2 = obj1;
46437 if (obj2) {
46438 ecode3 = SWIG_AsVal_int(obj2, &val3);
46439 if (!SWIG_IsOK(ecode3)) {
46440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46441 }
46442 arg3 = static_cast< int >(val3);
46443 }
46444 if (obj3) {
46445 ecode4 = SWIG_AsVal_int(obj3, &val4);
46446 if (!SWIG_IsOK(ecode4)) {
46447 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46448 }
46449 arg4 = static_cast< int >(val4);
46450 }
46451 if (obj4) {
46452 ecode5 = SWIG_AsVal_int(obj4, &val5);
46453 if (!SWIG_IsOK(ecode5)) {
46454 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46455 }
46456 arg5 = static_cast< int >(val5);
46457 }
46458 if (obj5) {
46459 arg6 = obj5;
46460 }
46461 {
46462 PyThreadState* __tstate = wxPyBeginAllowThreads();
46463 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46464 wxPyEndAllowThreads(__tstate);
46465 if (PyErr_Occurred()) SWIG_fail;
46466 }
46467 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46468 return resultobj;
46469 fail:
46470 return NULL;
46471 }
46472
46473
46474 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46475 PyObject *resultobj = 0;
46476 wxSizer *arg1 = (wxSizer *) 0 ;
46477 PyObject *arg2 = (PyObject *) 0 ;
46478 bool result;
46479 void *argp1 = 0 ;
46480 int res1 = 0 ;
46481 PyObject * obj0 = 0 ;
46482 PyObject * obj1 = 0 ;
46483 char * kwnames[] = {
46484 (char *) "self",(char *) "item", NULL
46485 };
46486
46487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46489 if (!SWIG_IsOK(res1)) {
46490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46491 }
46492 arg1 = reinterpret_cast< wxSizer * >(argp1);
46493 arg2 = obj1;
46494 {
46495 PyThreadState* __tstate = wxPyBeginAllowThreads();
46496 result = (bool)wxSizer_Remove(arg1,arg2);
46497 wxPyEndAllowThreads(__tstate);
46498 if (PyErr_Occurred()) SWIG_fail;
46499 }
46500 {
46501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46502 }
46503 return resultobj;
46504 fail:
46505 return NULL;
46506 }
46507
46508
46509 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46510 PyObject *resultobj = 0;
46511 wxSizer *arg1 = (wxSizer *) 0 ;
46512 PyObject *arg2 = (PyObject *) 0 ;
46513 bool result;
46514 void *argp1 = 0 ;
46515 int res1 = 0 ;
46516 PyObject * obj0 = 0 ;
46517 PyObject * obj1 = 0 ;
46518 char * kwnames[] = {
46519 (char *) "self",(char *) "item", NULL
46520 };
46521
46522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46524 if (!SWIG_IsOK(res1)) {
46525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46526 }
46527 arg1 = reinterpret_cast< wxSizer * >(argp1);
46528 arg2 = obj1;
46529 {
46530 PyThreadState* __tstate = wxPyBeginAllowThreads();
46531 result = (bool)wxSizer_Detach(arg1,arg2);
46532 wxPyEndAllowThreads(__tstate);
46533 if (PyErr_Occurred()) SWIG_fail;
46534 }
46535 {
46536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46537 }
46538 return resultobj;
46539 fail:
46540 return NULL;
46541 }
46542
46543
46544 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46545 PyObject *resultobj = 0;
46546 wxSizer *arg1 = (wxSizer *) 0 ;
46547 PyObject *arg2 = (PyObject *) 0 ;
46548 wxSizerItem *result = 0 ;
46549 void *argp1 = 0 ;
46550 int res1 = 0 ;
46551 PyObject * obj0 = 0 ;
46552 PyObject * obj1 = 0 ;
46553 char * kwnames[] = {
46554 (char *) "self",(char *) "item", NULL
46555 };
46556
46557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46559 if (!SWIG_IsOK(res1)) {
46560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46561 }
46562 arg1 = reinterpret_cast< wxSizer * >(argp1);
46563 arg2 = obj1;
46564 {
46565 PyThreadState* __tstate = wxPyBeginAllowThreads();
46566 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46567 wxPyEndAllowThreads(__tstate);
46568 if (PyErr_Occurred()) SWIG_fail;
46569 }
46570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46571 return resultobj;
46572 fail:
46573 return NULL;
46574 }
46575
46576
46577 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46578 PyObject *resultobj = 0;
46579 wxSizer *arg1 = (wxSizer *) 0 ;
46580 PyObject *arg2 = (PyObject *) 0 ;
46581 wxSize *arg3 = 0 ;
46582 void *argp1 = 0 ;
46583 int res1 = 0 ;
46584 wxSize temp3 ;
46585 PyObject * obj0 = 0 ;
46586 PyObject * obj1 = 0 ;
46587 PyObject * obj2 = 0 ;
46588 char * kwnames[] = {
46589 (char *) "self",(char *) "item",(char *) "size", NULL
46590 };
46591
46592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46594 if (!SWIG_IsOK(res1)) {
46595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46596 }
46597 arg1 = reinterpret_cast< wxSizer * >(argp1);
46598 arg2 = obj1;
46599 {
46600 arg3 = &temp3;
46601 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46602 }
46603 {
46604 PyThreadState* __tstate = wxPyBeginAllowThreads();
46605 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46606 wxPyEndAllowThreads(__tstate);
46607 if (PyErr_Occurred()) SWIG_fail;
46608 }
46609 resultobj = SWIG_Py_Void();
46610 return resultobj;
46611 fail:
46612 return NULL;
46613 }
46614
46615
46616 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46617 PyObject *resultobj = 0;
46618 wxSizer *arg1 = (wxSizer *) 0 ;
46619 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46620 wxSizerItem *result = 0 ;
46621 void *argp1 = 0 ;
46622 int res1 = 0 ;
46623 int res2 = 0 ;
46624 PyObject * obj0 = 0 ;
46625 PyObject * obj1 = 0 ;
46626 char * kwnames[] = {
46627 (char *) "self",(char *) "item", NULL
46628 };
46629
46630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46632 if (!SWIG_IsOK(res1)) {
46633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46634 }
46635 arg1 = reinterpret_cast< wxSizer * >(argp1);
46636 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46637 if (!SWIG_IsOK(res2)) {
46638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46639 }
46640 {
46641 PyThreadState* __tstate = wxPyBeginAllowThreads();
46642 result = (wxSizerItem *)(arg1)->Add(arg2);
46643 wxPyEndAllowThreads(__tstate);
46644 if (PyErr_Occurred()) SWIG_fail;
46645 }
46646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46647 return resultobj;
46648 fail:
46649 return NULL;
46650 }
46651
46652
46653 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46654 PyObject *resultobj = 0;
46655 wxSizer *arg1 = (wxSizer *) 0 ;
46656 size_t arg2 ;
46657 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46658 wxSizerItem *result = 0 ;
46659 void *argp1 = 0 ;
46660 int res1 = 0 ;
46661 size_t val2 ;
46662 int ecode2 = 0 ;
46663 int res3 = 0 ;
46664 PyObject * obj0 = 0 ;
46665 PyObject * obj1 = 0 ;
46666 PyObject * obj2 = 0 ;
46667 char * kwnames[] = {
46668 (char *) "self",(char *) "index",(char *) "item", NULL
46669 };
46670
46671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46673 if (!SWIG_IsOK(res1)) {
46674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46675 }
46676 arg1 = reinterpret_cast< wxSizer * >(argp1);
46677 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46678 if (!SWIG_IsOK(ecode2)) {
46679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46680 }
46681 arg2 = static_cast< size_t >(val2);
46682 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46683 if (!SWIG_IsOK(res3)) {
46684 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46685 }
46686 {
46687 PyThreadState* __tstate = wxPyBeginAllowThreads();
46688 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46689 wxPyEndAllowThreads(__tstate);
46690 if (PyErr_Occurred()) SWIG_fail;
46691 }
46692 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46693 return resultobj;
46694 fail:
46695 return NULL;
46696 }
46697
46698
46699 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46700 PyObject *resultobj = 0;
46701 wxSizer *arg1 = (wxSizer *) 0 ;
46702 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46703 wxSizerItem *result = 0 ;
46704 void *argp1 = 0 ;
46705 int res1 = 0 ;
46706 int res2 = 0 ;
46707 PyObject * obj0 = 0 ;
46708 PyObject * obj1 = 0 ;
46709 char * kwnames[] = {
46710 (char *) "self",(char *) "item", NULL
46711 };
46712
46713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46715 if (!SWIG_IsOK(res1)) {
46716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46717 }
46718 arg1 = reinterpret_cast< wxSizer * >(argp1);
46719 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46720 if (!SWIG_IsOK(res2)) {
46721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46722 }
46723 {
46724 PyThreadState* __tstate = wxPyBeginAllowThreads();
46725 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46726 wxPyEndAllowThreads(__tstate);
46727 if (PyErr_Occurred()) SWIG_fail;
46728 }
46729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46730 return resultobj;
46731 fail:
46732 return NULL;
46733 }
46734
46735
46736 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46737 PyObject *resultobj = 0;
46738 wxSizer *arg1 = (wxSizer *) 0 ;
46739 int arg2 ;
46740 int arg3 ;
46741 int arg4 ;
46742 int arg5 ;
46743 void *argp1 = 0 ;
46744 int res1 = 0 ;
46745 int val2 ;
46746 int ecode2 = 0 ;
46747 int val3 ;
46748 int ecode3 = 0 ;
46749 int val4 ;
46750 int ecode4 = 0 ;
46751 int val5 ;
46752 int ecode5 = 0 ;
46753 PyObject * obj0 = 0 ;
46754 PyObject * obj1 = 0 ;
46755 PyObject * obj2 = 0 ;
46756 PyObject * obj3 = 0 ;
46757 PyObject * obj4 = 0 ;
46758 char * kwnames[] = {
46759 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46760 };
46761
46762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46764 if (!SWIG_IsOK(res1)) {
46765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46766 }
46767 arg1 = reinterpret_cast< wxSizer * >(argp1);
46768 ecode2 = SWIG_AsVal_int(obj1, &val2);
46769 if (!SWIG_IsOK(ecode2)) {
46770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46771 }
46772 arg2 = static_cast< int >(val2);
46773 ecode3 = SWIG_AsVal_int(obj2, &val3);
46774 if (!SWIG_IsOK(ecode3)) {
46775 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46776 }
46777 arg3 = static_cast< int >(val3);
46778 ecode4 = SWIG_AsVal_int(obj3, &val4);
46779 if (!SWIG_IsOK(ecode4)) {
46780 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46781 }
46782 arg4 = static_cast< int >(val4);
46783 ecode5 = SWIG_AsVal_int(obj4, &val5);
46784 if (!SWIG_IsOK(ecode5)) {
46785 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46786 }
46787 arg5 = static_cast< int >(val5);
46788 {
46789 PyThreadState* __tstate = wxPyBeginAllowThreads();
46790 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46791 wxPyEndAllowThreads(__tstate);
46792 if (PyErr_Occurred()) SWIG_fail;
46793 }
46794 resultobj = SWIG_Py_Void();
46795 return resultobj;
46796 fail:
46797 return NULL;
46798 }
46799
46800
46801 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46802 PyObject *resultobj = 0;
46803 wxSizer *arg1 = (wxSizer *) 0 ;
46804 wxSize *arg2 = 0 ;
46805 void *argp1 = 0 ;
46806 int res1 = 0 ;
46807 wxSize temp2 ;
46808 PyObject * obj0 = 0 ;
46809 PyObject * obj1 = 0 ;
46810 char * kwnames[] = {
46811 (char *) "self",(char *) "size", NULL
46812 };
46813
46814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46816 if (!SWIG_IsOK(res1)) {
46817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46818 }
46819 arg1 = reinterpret_cast< wxSizer * >(argp1);
46820 {
46821 arg2 = &temp2;
46822 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46823 }
46824 {
46825 PyThreadState* __tstate = wxPyBeginAllowThreads();
46826 (arg1)->SetMinSize((wxSize const &)*arg2);
46827 wxPyEndAllowThreads(__tstate);
46828 if (PyErr_Occurred()) SWIG_fail;
46829 }
46830 resultobj = SWIG_Py_Void();
46831 return resultobj;
46832 fail:
46833 return NULL;
46834 }
46835
46836
46837 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46838 PyObject *resultobj = 0;
46839 wxSizer *arg1 = (wxSizer *) 0 ;
46840 wxSize 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_wxSizer, 0 | 0 );
46848 if (!SWIG_IsOK(res1)) {
46849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46850 }
46851 arg1 = reinterpret_cast< wxSizer * >(argp1);
46852 {
46853 PyThreadState* __tstate = wxPyBeginAllowThreads();
46854 result = (arg1)->GetSize();
46855 wxPyEndAllowThreads(__tstate);
46856 if (PyErr_Occurred()) SWIG_fail;
46857 }
46858 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46859 return resultobj;
46860 fail:
46861 return NULL;
46862 }
46863
46864
46865 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46866 PyObject *resultobj = 0;
46867 wxSizer *arg1 = (wxSizer *) 0 ;
46868 wxPoint result;
46869 void *argp1 = 0 ;
46870 int res1 = 0 ;
46871 PyObject *swig_obj[1] ;
46872
46873 if (!args) SWIG_fail;
46874 swig_obj[0] = args;
46875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46876 if (!SWIG_IsOK(res1)) {
46877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46878 }
46879 arg1 = reinterpret_cast< wxSizer * >(argp1);
46880 {
46881 PyThreadState* __tstate = wxPyBeginAllowThreads();
46882 result = (arg1)->GetPosition();
46883 wxPyEndAllowThreads(__tstate);
46884 if (PyErr_Occurred()) SWIG_fail;
46885 }
46886 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46887 return resultobj;
46888 fail:
46889 return NULL;
46890 }
46891
46892
46893 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46894 PyObject *resultobj = 0;
46895 wxSizer *arg1 = (wxSizer *) 0 ;
46896 wxSize result;
46897 void *argp1 = 0 ;
46898 int res1 = 0 ;
46899 PyObject *swig_obj[1] ;
46900
46901 if (!args) SWIG_fail;
46902 swig_obj[0] = args;
46903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46904 if (!SWIG_IsOK(res1)) {
46905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46906 }
46907 arg1 = reinterpret_cast< wxSizer * >(argp1);
46908 {
46909 PyThreadState* __tstate = wxPyBeginAllowThreads();
46910 result = (arg1)->GetMinSize();
46911 wxPyEndAllowThreads(__tstate);
46912 if (PyErr_Occurred()) SWIG_fail;
46913 }
46914 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46915 return resultobj;
46916 fail:
46917 return NULL;
46918 }
46919
46920
46921 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46922 PyObject *resultobj = 0;
46923 wxSizer *arg1 = (wxSizer *) 0 ;
46924 void *argp1 = 0 ;
46925 int res1 = 0 ;
46926 PyObject *swig_obj[1] ;
46927
46928 if (!args) SWIG_fail;
46929 swig_obj[0] = args;
46930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46931 if (!SWIG_IsOK(res1)) {
46932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46933 }
46934 arg1 = reinterpret_cast< wxSizer * >(argp1);
46935 {
46936 PyThreadState* __tstate = wxPyBeginAllowThreads();
46937 (arg1)->RecalcSizes();
46938 wxPyEndAllowThreads(__tstate);
46939 if (PyErr_Occurred()) SWIG_fail;
46940 }
46941 resultobj = SWIG_Py_Void();
46942 return resultobj;
46943 fail:
46944 return NULL;
46945 }
46946
46947
46948 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46949 PyObject *resultobj = 0;
46950 wxSizer *arg1 = (wxSizer *) 0 ;
46951 wxSize result;
46952 void *argp1 = 0 ;
46953 int res1 = 0 ;
46954 PyObject *swig_obj[1] ;
46955
46956 if (!args) SWIG_fail;
46957 swig_obj[0] = args;
46958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46959 if (!SWIG_IsOK(res1)) {
46960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46961 }
46962 arg1 = reinterpret_cast< wxSizer * >(argp1);
46963 {
46964 PyThreadState* __tstate = wxPyBeginAllowThreads();
46965 result = (arg1)->CalcMin();
46966 wxPyEndAllowThreads(__tstate);
46967 if (PyErr_Occurred()) SWIG_fail;
46968 }
46969 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46970 return resultobj;
46971 fail:
46972 return NULL;
46973 }
46974
46975
46976 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46977 PyObject *resultobj = 0;
46978 wxSizer *arg1 = (wxSizer *) 0 ;
46979 void *argp1 = 0 ;
46980 int res1 = 0 ;
46981 PyObject *swig_obj[1] ;
46982
46983 if (!args) SWIG_fail;
46984 swig_obj[0] = args;
46985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46986 if (!SWIG_IsOK(res1)) {
46987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46988 }
46989 arg1 = reinterpret_cast< wxSizer * >(argp1);
46990 {
46991 PyThreadState* __tstate = wxPyBeginAllowThreads();
46992 (arg1)->Layout();
46993 wxPyEndAllowThreads(__tstate);
46994 if (PyErr_Occurred()) SWIG_fail;
46995 }
46996 resultobj = SWIG_Py_Void();
46997 return resultobj;
46998 fail:
46999 return NULL;
47000 }
47001
47002
47003 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47004 PyObject *resultobj = 0;
47005 wxSizer *arg1 = (wxSizer *) 0 ;
47006 wxWindow *arg2 = (wxWindow *) 0 ;
47007 wxSize result;
47008 void *argp1 = 0 ;
47009 int res1 = 0 ;
47010 void *argp2 = 0 ;
47011 int res2 = 0 ;
47012 PyObject * obj0 = 0 ;
47013 PyObject * obj1 = 0 ;
47014 char * kwnames[] = {
47015 (char *) "self",(char *) "window", NULL
47016 };
47017
47018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47020 if (!SWIG_IsOK(res1)) {
47021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47022 }
47023 arg1 = reinterpret_cast< wxSizer * >(argp1);
47024 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47025 if (!SWIG_IsOK(res2)) {
47026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47027 }
47028 arg2 = reinterpret_cast< wxWindow * >(argp2);
47029 {
47030 PyThreadState* __tstate = wxPyBeginAllowThreads();
47031 result = (arg1)->Fit(arg2);
47032 wxPyEndAllowThreads(__tstate);
47033 if (PyErr_Occurred()) SWIG_fail;
47034 }
47035 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47036 return resultobj;
47037 fail:
47038 return NULL;
47039 }
47040
47041
47042 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47043 PyObject *resultobj = 0;
47044 wxSizer *arg1 = (wxSizer *) 0 ;
47045 wxWindow *arg2 = (wxWindow *) 0 ;
47046 void *argp1 = 0 ;
47047 int res1 = 0 ;
47048 void *argp2 = 0 ;
47049 int res2 = 0 ;
47050 PyObject * obj0 = 0 ;
47051 PyObject * obj1 = 0 ;
47052 char * kwnames[] = {
47053 (char *) "self",(char *) "window", NULL
47054 };
47055
47056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47058 if (!SWIG_IsOK(res1)) {
47059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47060 }
47061 arg1 = reinterpret_cast< wxSizer * >(argp1);
47062 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47063 if (!SWIG_IsOK(res2)) {
47064 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47065 }
47066 arg2 = reinterpret_cast< wxWindow * >(argp2);
47067 {
47068 PyThreadState* __tstate = wxPyBeginAllowThreads();
47069 (arg1)->FitInside(arg2);
47070 wxPyEndAllowThreads(__tstate);
47071 if (PyErr_Occurred()) SWIG_fail;
47072 }
47073 resultobj = SWIG_Py_Void();
47074 return resultobj;
47075 fail:
47076 return NULL;
47077 }
47078
47079
47080 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47081 PyObject *resultobj = 0;
47082 wxSizer *arg1 = (wxSizer *) 0 ;
47083 wxWindow *arg2 = (wxWindow *) 0 ;
47084 void *argp1 = 0 ;
47085 int res1 = 0 ;
47086 void *argp2 = 0 ;
47087 int res2 = 0 ;
47088 PyObject * obj0 = 0 ;
47089 PyObject * obj1 = 0 ;
47090 char * kwnames[] = {
47091 (char *) "self",(char *) "window", NULL
47092 };
47093
47094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47096 if (!SWIG_IsOK(res1)) {
47097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47098 }
47099 arg1 = reinterpret_cast< wxSizer * >(argp1);
47100 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47101 if (!SWIG_IsOK(res2)) {
47102 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47103 }
47104 arg2 = reinterpret_cast< wxWindow * >(argp2);
47105 {
47106 PyThreadState* __tstate = wxPyBeginAllowThreads();
47107 (arg1)->SetSizeHints(arg2);
47108 wxPyEndAllowThreads(__tstate);
47109 if (PyErr_Occurred()) SWIG_fail;
47110 }
47111 resultobj = SWIG_Py_Void();
47112 return resultobj;
47113 fail:
47114 return NULL;
47115 }
47116
47117
47118 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47119 PyObject *resultobj = 0;
47120 wxSizer *arg1 = (wxSizer *) 0 ;
47121 wxWindow *arg2 = (wxWindow *) 0 ;
47122 void *argp1 = 0 ;
47123 int res1 = 0 ;
47124 void *argp2 = 0 ;
47125 int res2 = 0 ;
47126 PyObject * obj0 = 0 ;
47127 PyObject * obj1 = 0 ;
47128 char * kwnames[] = {
47129 (char *) "self",(char *) "window", NULL
47130 };
47131
47132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47134 if (!SWIG_IsOK(res1)) {
47135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47136 }
47137 arg1 = reinterpret_cast< wxSizer * >(argp1);
47138 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47139 if (!SWIG_IsOK(res2)) {
47140 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47141 }
47142 arg2 = reinterpret_cast< wxWindow * >(argp2);
47143 {
47144 PyThreadState* __tstate = wxPyBeginAllowThreads();
47145 (arg1)->SetVirtualSizeHints(arg2);
47146 wxPyEndAllowThreads(__tstate);
47147 if (PyErr_Occurred()) SWIG_fail;
47148 }
47149 resultobj = SWIG_Py_Void();
47150 return resultobj;
47151 fail:
47152 return NULL;
47153 }
47154
47155
47156 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47157 PyObject *resultobj = 0;
47158 wxSizer *arg1 = (wxSizer *) 0 ;
47159 bool arg2 = (bool) false ;
47160 void *argp1 = 0 ;
47161 int res1 = 0 ;
47162 bool val2 ;
47163 int ecode2 = 0 ;
47164 PyObject * obj0 = 0 ;
47165 PyObject * obj1 = 0 ;
47166 char * kwnames[] = {
47167 (char *) "self",(char *) "deleteWindows", NULL
47168 };
47169
47170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47172 if (!SWIG_IsOK(res1)) {
47173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47174 }
47175 arg1 = reinterpret_cast< wxSizer * >(argp1);
47176 if (obj1) {
47177 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47178 if (!SWIG_IsOK(ecode2)) {
47179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47180 }
47181 arg2 = static_cast< bool >(val2);
47182 }
47183 {
47184 PyThreadState* __tstate = wxPyBeginAllowThreads();
47185 (arg1)->Clear(arg2);
47186 wxPyEndAllowThreads(__tstate);
47187 if (PyErr_Occurred()) SWIG_fail;
47188 }
47189 resultobj = SWIG_Py_Void();
47190 return resultobj;
47191 fail:
47192 return NULL;
47193 }
47194
47195
47196 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47197 PyObject *resultobj = 0;
47198 wxSizer *arg1 = (wxSizer *) 0 ;
47199 void *argp1 = 0 ;
47200 int res1 = 0 ;
47201 PyObject *swig_obj[1] ;
47202
47203 if (!args) SWIG_fail;
47204 swig_obj[0] = args;
47205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47206 if (!SWIG_IsOK(res1)) {
47207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47208 }
47209 arg1 = reinterpret_cast< wxSizer * >(argp1);
47210 {
47211 PyThreadState* __tstate = wxPyBeginAllowThreads();
47212 (arg1)->DeleteWindows();
47213 wxPyEndAllowThreads(__tstate);
47214 if (PyErr_Occurred()) SWIG_fail;
47215 }
47216 resultobj = SWIG_Py_Void();
47217 return resultobj;
47218 fail:
47219 return NULL;
47220 }
47221
47222
47223 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47224 PyObject *resultobj = 0;
47225 wxSizer *arg1 = (wxSizer *) 0 ;
47226 PyObject *result = 0 ;
47227 void *argp1 = 0 ;
47228 int res1 = 0 ;
47229 PyObject *swig_obj[1] ;
47230
47231 if (!args) SWIG_fail;
47232 swig_obj[0] = args;
47233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47234 if (!SWIG_IsOK(res1)) {
47235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47236 }
47237 arg1 = reinterpret_cast< wxSizer * >(argp1);
47238 {
47239 PyThreadState* __tstate = wxPyBeginAllowThreads();
47240 result = (PyObject *)wxSizer_GetChildren(arg1);
47241 wxPyEndAllowThreads(__tstate);
47242 if (PyErr_Occurred()) SWIG_fail;
47243 }
47244 resultobj = result;
47245 return resultobj;
47246 fail:
47247 return NULL;
47248 }
47249
47250
47251 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47252 PyObject *resultobj = 0;
47253 wxSizer *arg1 = (wxSizer *) 0 ;
47254 PyObject *arg2 = (PyObject *) 0 ;
47255 bool arg3 = (bool) true ;
47256 bool arg4 = (bool) false ;
47257 bool result;
47258 void *argp1 = 0 ;
47259 int res1 = 0 ;
47260 bool val3 ;
47261 int ecode3 = 0 ;
47262 bool val4 ;
47263 int ecode4 = 0 ;
47264 PyObject * obj0 = 0 ;
47265 PyObject * obj1 = 0 ;
47266 PyObject * obj2 = 0 ;
47267 PyObject * obj3 = 0 ;
47268 char * kwnames[] = {
47269 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47270 };
47271
47272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47274 if (!SWIG_IsOK(res1)) {
47275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47276 }
47277 arg1 = reinterpret_cast< wxSizer * >(argp1);
47278 arg2 = obj1;
47279 if (obj2) {
47280 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47281 if (!SWIG_IsOK(ecode3)) {
47282 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47283 }
47284 arg3 = static_cast< bool >(val3);
47285 }
47286 if (obj3) {
47287 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47288 if (!SWIG_IsOK(ecode4)) {
47289 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47290 }
47291 arg4 = static_cast< bool >(val4);
47292 }
47293 {
47294 PyThreadState* __tstate = wxPyBeginAllowThreads();
47295 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47296 wxPyEndAllowThreads(__tstate);
47297 if (PyErr_Occurred()) SWIG_fail;
47298 }
47299 {
47300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47301 }
47302 return resultobj;
47303 fail:
47304 return NULL;
47305 }
47306
47307
47308 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47309 PyObject *resultobj = 0;
47310 wxSizer *arg1 = (wxSizer *) 0 ;
47311 PyObject *arg2 = (PyObject *) 0 ;
47312 bool result;
47313 void *argp1 = 0 ;
47314 int res1 = 0 ;
47315 PyObject * obj0 = 0 ;
47316 PyObject * obj1 = 0 ;
47317 char * kwnames[] = {
47318 (char *) "self",(char *) "item", NULL
47319 };
47320
47321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47323 if (!SWIG_IsOK(res1)) {
47324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47325 }
47326 arg1 = reinterpret_cast< wxSizer * >(argp1);
47327 arg2 = obj1;
47328 {
47329 PyThreadState* __tstate = wxPyBeginAllowThreads();
47330 result = (bool)wxSizer_IsShown(arg1,arg2);
47331 wxPyEndAllowThreads(__tstate);
47332 if (PyErr_Occurred()) SWIG_fail;
47333 }
47334 {
47335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47336 }
47337 return resultobj;
47338 fail:
47339 return NULL;
47340 }
47341
47342
47343 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47344 PyObject *resultobj = 0;
47345 wxSizer *arg1 = (wxSizer *) 0 ;
47346 bool arg2 ;
47347 void *argp1 = 0 ;
47348 int res1 = 0 ;
47349 bool val2 ;
47350 int ecode2 = 0 ;
47351 PyObject * obj0 = 0 ;
47352 PyObject * obj1 = 0 ;
47353 char * kwnames[] = {
47354 (char *) "self",(char *) "show", NULL
47355 };
47356
47357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47359 if (!SWIG_IsOK(res1)) {
47360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47361 }
47362 arg1 = reinterpret_cast< wxSizer * >(argp1);
47363 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47364 if (!SWIG_IsOK(ecode2)) {
47365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47366 }
47367 arg2 = static_cast< bool >(val2);
47368 {
47369 PyThreadState* __tstate = wxPyBeginAllowThreads();
47370 (arg1)->ShowItems(arg2);
47371 wxPyEndAllowThreads(__tstate);
47372 if (PyErr_Occurred()) SWIG_fail;
47373 }
47374 resultobj = SWIG_Py_Void();
47375 return resultobj;
47376 fail:
47377 return NULL;
47378 }
47379
47380
47381 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47382 PyObject *obj;
47383 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47384 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47385 return SWIG_Py_Void();
47386 }
47387
47388 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47389 PyObject *resultobj = 0;
47390 wxPySizer *result = 0 ;
47391
47392 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47393 {
47394 PyThreadState* __tstate = wxPyBeginAllowThreads();
47395 result = (wxPySizer *)new wxPySizer();
47396 wxPyEndAllowThreads(__tstate);
47397 if (PyErr_Occurred()) SWIG_fail;
47398 }
47399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47400 return resultobj;
47401 fail:
47402 return NULL;
47403 }
47404
47405
47406 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47407 PyObject *resultobj = 0;
47408 wxPySizer *arg1 = (wxPySizer *) 0 ;
47409 PyObject *arg2 = (PyObject *) 0 ;
47410 PyObject *arg3 = (PyObject *) 0 ;
47411 void *argp1 = 0 ;
47412 int res1 = 0 ;
47413 PyObject * obj0 = 0 ;
47414 PyObject * obj1 = 0 ;
47415 PyObject * obj2 = 0 ;
47416 char * kwnames[] = {
47417 (char *) "self",(char *) "self",(char *) "_class", NULL
47418 };
47419
47420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47422 if (!SWIG_IsOK(res1)) {
47423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47424 }
47425 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47426 arg2 = obj1;
47427 arg3 = obj2;
47428 {
47429 PyThreadState* __tstate = wxPyBeginAllowThreads();
47430 (arg1)->_setCallbackInfo(arg2,arg3);
47431 wxPyEndAllowThreads(__tstate);
47432 if (PyErr_Occurred()) SWIG_fail;
47433 }
47434 resultobj = SWIG_Py_Void();
47435 return resultobj;
47436 fail:
47437 return NULL;
47438 }
47439
47440
47441 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47442 PyObject *obj;
47443 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47444 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47445 return SWIG_Py_Void();
47446 }
47447
47448 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47449 return SWIG_Python_InitShadowInstance(args);
47450 }
47451
47452 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47453 PyObject *resultobj = 0;
47454 int arg1 = (int) wxHORIZONTAL ;
47455 wxBoxSizer *result = 0 ;
47456 int val1 ;
47457 int ecode1 = 0 ;
47458 PyObject * obj0 = 0 ;
47459 char * kwnames[] = {
47460 (char *) "orient", NULL
47461 };
47462
47463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47464 if (obj0) {
47465 ecode1 = SWIG_AsVal_int(obj0, &val1);
47466 if (!SWIG_IsOK(ecode1)) {
47467 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47468 }
47469 arg1 = static_cast< int >(val1);
47470 }
47471 {
47472 PyThreadState* __tstate = wxPyBeginAllowThreads();
47473 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47474 wxPyEndAllowThreads(__tstate);
47475 if (PyErr_Occurred()) SWIG_fail;
47476 }
47477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47478 return resultobj;
47479 fail:
47480 return NULL;
47481 }
47482
47483
47484 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47485 PyObject *resultobj = 0;
47486 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47487 int result;
47488 void *argp1 = 0 ;
47489 int res1 = 0 ;
47490 PyObject *swig_obj[1] ;
47491
47492 if (!args) SWIG_fail;
47493 swig_obj[0] = args;
47494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47495 if (!SWIG_IsOK(res1)) {
47496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47497 }
47498 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47499 {
47500 PyThreadState* __tstate = wxPyBeginAllowThreads();
47501 result = (int)(arg1)->GetOrientation();
47502 wxPyEndAllowThreads(__tstate);
47503 if (PyErr_Occurred()) SWIG_fail;
47504 }
47505 resultobj = SWIG_From_int(static_cast< int >(result));
47506 return resultobj;
47507 fail:
47508 return NULL;
47509 }
47510
47511
47512 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47513 PyObject *resultobj = 0;
47514 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47515 int arg2 ;
47516 void *argp1 = 0 ;
47517 int res1 = 0 ;
47518 int val2 ;
47519 int ecode2 = 0 ;
47520 PyObject * obj0 = 0 ;
47521 PyObject * obj1 = 0 ;
47522 char * kwnames[] = {
47523 (char *) "self",(char *) "orient", NULL
47524 };
47525
47526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47528 if (!SWIG_IsOK(res1)) {
47529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47530 }
47531 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47532 ecode2 = SWIG_AsVal_int(obj1, &val2);
47533 if (!SWIG_IsOK(ecode2)) {
47534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47535 }
47536 arg2 = static_cast< int >(val2);
47537 {
47538 PyThreadState* __tstate = wxPyBeginAllowThreads();
47539 (arg1)->SetOrientation(arg2);
47540 wxPyEndAllowThreads(__tstate);
47541 if (PyErr_Occurred()) SWIG_fail;
47542 }
47543 resultobj = SWIG_Py_Void();
47544 return resultobj;
47545 fail:
47546 return NULL;
47547 }
47548
47549
47550 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47551 PyObject *obj;
47552 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47553 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47554 return SWIG_Py_Void();
47555 }
47556
47557 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47558 return SWIG_Python_InitShadowInstance(args);
47559 }
47560
47561 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47562 PyObject *resultobj = 0;
47563 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47564 int arg2 = (int) wxHORIZONTAL ;
47565 wxStaticBoxSizer *result = 0 ;
47566 void *argp1 = 0 ;
47567 int res1 = 0 ;
47568 int val2 ;
47569 int ecode2 = 0 ;
47570 PyObject * obj0 = 0 ;
47571 PyObject * obj1 = 0 ;
47572 char * kwnames[] = {
47573 (char *) "box",(char *) "orient", NULL
47574 };
47575
47576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47578 if (!SWIG_IsOK(res1)) {
47579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47580 }
47581 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47582 if (obj1) {
47583 ecode2 = SWIG_AsVal_int(obj1, &val2);
47584 if (!SWIG_IsOK(ecode2)) {
47585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47586 }
47587 arg2 = static_cast< int >(val2);
47588 }
47589 {
47590 PyThreadState* __tstate = wxPyBeginAllowThreads();
47591 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47592 wxPyEndAllowThreads(__tstate);
47593 if (PyErr_Occurred()) SWIG_fail;
47594 }
47595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47596 return resultobj;
47597 fail:
47598 return NULL;
47599 }
47600
47601
47602 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47603 PyObject *resultobj = 0;
47604 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47605 wxStaticBox *result = 0 ;
47606 void *argp1 = 0 ;
47607 int res1 = 0 ;
47608 PyObject *swig_obj[1] ;
47609
47610 if (!args) SWIG_fail;
47611 swig_obj[0] = args;
47612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47613 if (!SWIG_IsOK(res1)) {
47614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47615 }
47616 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47617 {
47618 PyThreadState* __tstate = wxPyBeginAllowThreads();
47619 result = (wxStaticBox *)(arg1)->GetStaticBox();
47620 wxPyEndAllowThreads(__tstate);
47621 if (PyErr_Occurred()) SWIG_fail;
47622 }
47623 {
47624 resultobj = wxPyMake_wxObject(result, (bool)0);
47625 }
47626 return resultobj;
47627 fail:
47628 return NULL;
47629 }
47630
47631
47632 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47633 PyObject *obj;
47634 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47635 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47636 return SWIG_Py_Void();
47637 }
47638
47639 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47640 return SWIG_Python_InitShadowInstance(args);
47641 }
47642
47643 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47644 PyObject *resultobj = 0;
47645 int arg1 = (int) 1 ;
47646 int arg2 = (int) 0 ;
47647 int arg3 = (int) 0 ;
47648 int arg4 = (int) 0 ;
47649 wxGridSizer *result = 0 ;
47650 int val1 ;
47651 int ecode1 = 0 ;
47652 int val2 ;
47653 int ecode2 = 0 ;
47654 int val3 ;
47655 int ecode3 = 0 ;
47656 int val4 ;
47657 int ecode4 = 0 ;
47658 PyObject * obj0 = 0 ;
47659 PyObject * obj1 = 0 ;
47660 PyObject * obj2 = 0 ;
47661 PyObject * obj3 = 0 ;
47662 char * kwnames[] = {
47663 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47664 };
47665
47666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47667 if (obj0) {
47668 ecode1 = SWIG_AsVal_int(obj0, &val1);
47669 if (!SWIG_IsOK(ecode1)) {
47670 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47671 }
47672 arg1 = static_cast< int >(val1);
47673 }
47674 if (obj1) {
47675 ecode2 = SWIG_AsVal_int(obj1, &val2);
47676 if (!SWIG_IsOK(ecode2)) {
47677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47678 }
47679 arg2 = static_cast< int >(val2);
47680 }
47681 if (obj2) {
47682 ecode3 = SWIG_AsVal_int(obj2, &val3);
47683 if (!SWIG_IsOK(ecode3)) {
47684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47685 }
47686 arg3 = static_cast< int >(val3);
47687 }
47688 if (obj3) {
47689 ecode4 = SWIG_AsVal_int(obj3, &val4);
47690 if (!SWIG_IsOK(ecode4)) {
47691 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47692 }
47693 arg4 = static_cast< int >(val4);
47694 }
47695 {
47696 PyThreadState* __tstate = wxPyBeginAllowThreads();
47697 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47698 wxPyEndAllowThreads(__tstate);
47699 if (PyErr_Occurred()) SWIG_fail;
47700 }
47701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47702 return resultobj;
47703 fail:
47704 return NULL;
47705 }
47706
47707
47708 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47709 PyObject *resultobj = 0;
47710 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47711 int arg2 ;
47712 void *argp1 = 0 ;
47713 int res1 = 0 ;
47714 int val2 ;
47715 int ecode2 = 0 ;
47716 PyObject * obj0 = 0 ;
47717 PyObject * obj1 = 0 ;
47718 char * kwnames[] = {
47719 (char *) "self",(char *) "cols", NULL
47720 };
47721
47722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47724 if (!SWIG_IsOK(res1)) {
47725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47726 }
47727 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47728 ecode2 = SWIG_AsVal_int(obj1, &val2);
47729 if (!SWIG_IsOK(ecode2)) {
47730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47731 }
47732 arg2 = static_cast< int >(val2);
47733 {
47734 PyThreadState* __tstate = wxPyBeginAllowThreads();
47735 (arg1)->SetCols(arg2);
47736 wxPyEndAllowThreads(__tstate);
47737 if (PyErr_Occurred()) SWIG_fail;
47738 }
47739 resultobj = SWIG_Py_Void();
47740 return resultobj;
47741 fail:
47742 return NULL;
47743 }
47744
47745
47746 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47747 PyObject *resultobj = 0;
47748 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47749 int arg2 ;
47750 void *argp1 = 0 ;
47751 int res1 = 0 ;
47752 int val2 ;
47753 int ecode2 = 0 ;
47754 PyObject * obj0 = 0 ;
47755 PyObject * obj1 = 0 ;
47756 char * kwnames[] = {
47757 (char *) "self",(char *) "rows", NULL
47758 };
47759
47760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47762 if (!SWIG_IsOK(res1)) {
47763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47764 }
47765 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47766 ecode2 = SWIG_AsVal_int(obj1, &val2);
47767 if (!SWIG_IsOK(ecode2)) {
47768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47769 }
47770 arg2 = static_cast< int >(val2);
47771 {
47772 PyThreadState* __tstate = wxPyBeginAllowThreads();
47773 (arg1)->SetRows(arg2);
47774 wxPyEndAllowThreads(__tstate);
47775 if (PyErr_Occurred()) SWIG_fail;
47776 }
47777 resultobj = SWIG_Py_Void();
47778 return resultobj;
47779 fail:
47780 return NULL;
47781 }
47782
47783
47784 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47785 PyObject *resultobj = 0;
47786 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47787 int arg2 ;
47788 void *argp1 = 0 ;
47789 int res1 = 0 ;
47790 int val2 ;
47791 int ecode2 = 0 ;
47792 PyObject * obj0 = 0 ;
47793 PyObject * obj1 = 0 ;
47794 char * kwnames[] = {
47795 (char *) "self",(char *) "gap", NULL
47796 };
47797
47798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47800 if (!SWIG_IsOK(res1)) {
47801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47802 }
47803 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47804 ecode2 = SWIG_AsVal_int(obj1, &val2);
47805 if (!SWIG_IsOK(ecode2)) {
47806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47807 }
47808 arg2 = static_cast< int >(val2);
47809 {
47810 PyThreadState* __tstate = wxPyBeginAllowThreads();
47811 (arg1)->SetVGap(arg2);
47812 wxPyEndAllowThreads(__tstate);
47813 if (PyErr_Occurred()) SWIG_fail;
47814 }
47815 resultobj = SWIG_Py_Void();
47816 return resultobj;
47817 fail:
47818 return NULL;
47819 }
47820
47821
47822 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47823 PyObject *resultobj = 0;
47824 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47825 int arg2 ;
47826 void *argp1 = 0 ;
47827 int res1 = 0 ;
47828 int val2 ;
47829 int ecode2 = 0 ;
47830 PyObject * obj0 = 0 ;
47831 PyObject * obj1 = 0 ;
47832 char * kwnames[] = {
47833 (char *) "self",(char *) "gap", NULL
47834 };
47835
47836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47838 if (!SWIG_IsOK(res1)) {
47839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47840 }
47841 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47842 ecode2 = SWIG_AsVal_int(obj1, &val2);
47843 if (!SWIG_IsOK(ecode2)) {
47844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47845 }
47846 arg2 = static_cast< int >(val2);
47847 {
47848 PyThreadState* __tstate = wxPyBeginAllowThreads();
47849 (arg1)->SetHGap(arg2);
47850 wxPyEndAllowThreads(__tstate);
47851 if (PyErr_Occurred()) SWIG_fail;
47852 }
47853 resultobj = SWIG_Py_Void();
47854 return resultobj;
47855 fail:
47856 return NULL;
47857 }
47858
47859
47860 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47861 PyObject *resultobj = 0;
47862 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47863 int result;
47864 void *argp1 = 0 ;
47865 int res1 = 0 ;
47866 PyObject *swig_obj[1] ;
47867
47868 if (!args) SWIG_fail;
47869 swig_obj[0] = args;
47870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47871 if (!SWIG_IsOK(res1)) {
47872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47873 }
47874 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47875 {
47876 PyThreadState* __tstate = wxPyBeginAllowThreads();
47877 result = (int)(arg1)->GetCols();
47878 wxPyEndAllowThreads(__tstate);
47879 if (PyErr_Occurred()) SWIG_fail;
47880 }
47881 resultobj = SWIG_From_int(static_cast< int >(result));
47882 return resultobj;
47883 fail:
47884 return NULL;
47885 }
47886
47887
47888 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47889 PyObject *resultobj = 0;
47890 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47891 int result;
47892 void *argp1 = 0 ;
47893 int res1 = 0 ;
47894 PyObject *swig_obj[1] ;
47895
47896 if (!args) SWIG_fail;
47897 swig_obj[0] = args;
47898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47899 if (!SWIG_IsOK(res1)) {
47900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47901 }
47902 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47903 {
47904 PyThreadState* __tstate = wxPyBeginAllowThreads();
47905 result = (int)(arg1)->GetRows();
47906 wxPyEndAllowThreads(__tstate);
47907 if (PyErr_Occurred()) SWIG_fail;
47908 }
47909 resultobj = SWIG_From_int(static_cast< int >(result));
47910 return resultobj;
47911 fail:
47912 return NULL;
47913 }
47914
47915
47916 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47917 PyObject *resultobj = 0;
47918 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47919 int result;
47920 void *argp1 = 0 ;
47921 int res1 = 0 ;
47922 PyObject *swig_obj[1] ;
47923
47924 if (!args) SWIG_fail;
47925 swig_obj[0] = args;
47926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47927 if (!SWIG_IsOK(res1)) {
47928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47929 }
47930 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47931 {
47932 PyThreadState* __tstate = wxPyBeginAllowThreads();
47933 result = (int)(arg1)->GetVGap();
47934 wxPyEndAllowThreads(__tstate);
47935 if (PyErr_Occurred()) SWIG_fail;
47936 }
47937 resultobj = SWIG_From_int(static_cast< int >(result));
47938 return resultobj;
47939 fail:
47940 return NULL;
47941 }
47942
47943
47944 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47945 PyObject *resultobj = 0;
47946 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47947 int result;
47948 void *argp1 = 0 ;
47949 int res1 = 0 ;
47950 PyObject *swig_obj[1] ;
47951
47952 if (!args) SWIG_fail;
47953 swig_obj[0] = args;
47954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47955 if (!SWIG_IsOK(res1)) {
47956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47957 }
47958 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47959 {
47960 PyThreadState* __tstate = wxPyBeginAllowThreads();
47961 result = (int)(arg1)->GetHGap();
47962 wxPyEndAllowThreads(__tstate);
47963 if (PyErr_Occurred()) SWIG_fail;
47964 }
47965 resultobj = SWIG_From_int(static_cast< int >(result));
47966 return resultobj;
47967 fail:
47968 return NULL;
47969 }
47970
47971
47972 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47973 PyObject *obj;
47974 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47975 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47976 return SWIG_Py_Void();
47977 }
47978
47979 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47980 return SWIG_Python_InitShadowInstance(args);
47981 }
47982
47983 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47984 PyObject *resultobj = 0;
47985 int arg1 = (int) 1 ;
47986 int arg2 = (int) 0 ;
47987 int arg3 = (int) 0 ;
47988 int arg4 = (int) 0 ;
47989 wxFlexGridSizer *result = 0 ;
47990 int val1 ;
47991 int ecode1 = 0 ;
47992 int val2 ;
47993 int ecode2 = 0 ;
47994 int val3 ;
47995 int ecode3 = 0 ;
47996 int val4 ;
47997 int ecode4 = 0 ;
47998 PyObject * obj0 = 0 ;
47999 PyObject * obj1 = 0 ;
48000 PyObject * obj2 = 0 ;
48001 PyObject * obj3 = 0 ;
48002 char * kwnames[] = {
48003 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48004 };
48005
48006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48007 if (obj0) {
48008 ecode1 = SWIG_AsVal_int(obj0, &val1);
48009 if (!SWIG_IsOK(ecode1)) {
48010 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48011 }
48012 arg1 = static_cast< int >(val1);
48013 }
48014 if (obj1) {
48015 ecode2 = SWIG_AsVal_int(obj1, &val2);
48016 if (!SWIG_IsOK(ecode2)) {
48017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48018 }
48019 arg2 = static_cast< int >(val2);
48020 }
48021 if (obj2) {
48022 ecode3 = SWIG_AsVal_int(obj2, &val3);
48023 if (!SWIG_IsOK(ecode3)) {
48024 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48025 }
48026 arg3 = static_cast< int >(val3);
48027 }
48028 if (obj3) {
48029 ecode4 = SWIG_AsVal_int(obj3, &val4);
48030 if (!SWIG_IsOK(ecode4)) {
48031 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48032 }
48033 arg4 = static_cast< int >(val4);
48034 }
48035 {
48036 PyThreadState* __tstate = wxPyBeginAllowThreads();
48037 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48038 wxPyEndAllowThreads(__tstate);
48039 if (PyErr_Occurred()) SWIG_fail;
48040 }
48041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48042 return resultobj;
48043 fail:
48044 return NULL;
48045 }
48046
48047
48048 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48049 PyObject *resultobj = 0;
48050 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48051 size_t arg2 ;
48052 int arg3 = (int) 0 ;
48053 void *argp1 = 0 ;
48054 int res1 = 0 ;
48055 size_t val2 ;
48056 int ecode2 = 0 ;
48057 int val3 ;
48058 int ecode3 = 0 ;
48059 PyObject * obj0 = 0 ;
48060 PyObject * obj1 = 0 ;
48061 PyObject * obj2 = 0 ;
48062 char * kwnames[] = {
48063 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48064 };
48065
48066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48068 if (!SWIG_IsOK(res1)) {
48069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48070 }
48071 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48072 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48073 if (!SWIG_IsOK(ecode2)) {
48074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48075 }
48076 arg2 = static_cast< size_t >(val2);
48077 if (obj2) {
48078 ecode3 = SWIG_AsVal_int(obj2, &val3);
48079 if (!SWIG_IsOK(ecode3)) {
48080 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48081 }
48082 arg3 = static_cast< int >(val3);
48083 }
48084 {
48085 PyThreadState* __tstate = wxPyBeginAllowThreads();
48086 (arg1)->AddGrowableRow(arg2,arg3);
48087 wxPyEndAllowThreads(__tstate);
48088 if (PyErr_Occurred()) SWIG_fail;
48089 }
48090 resultobj = SWIG_Py_Void();
48091 return resultobj;
48092 fail:
48093 return NULL;
48094 }
48095
48096
48097 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48098 PyObject *resultobj = 0;
48099 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48100 size_t arg2 ;
48101 void *argp1 = 0 ;
48102 int res1 = 0 ;
48103 size_t val2 ;
48104 int ecode2 = 0 ;
48105 PyObject * obj0 = 0 ;
48106 PyObject * obj1 = 0 ;
48107 char * kwnames[] = {
48108 (char *) "self",(char *) "idx", NULL
48109 };
48110
48111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48113 if (!SWIG_IsOK(res1)) {
48114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48115 }
48116 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48117 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48118 if (!SWIG_IsOK(ecode2)) {
48119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48120 }
48121 arg2 = static_cast< size_t >(val2);
48122 {
48123 PyThreadState* __tstate = wxPyBeginAllowThreads();
48124 (arg1)->RemoveGrowableRow(arg2);
48125 wxPyEndAllowThreads(__tstate);
48126 if (PyErr_Occurred()) SWIG_fail;
48127 }
48128 resultobj = SWIG_Py_Void();
48129 return resultobj;
48130 fail:
48131 return NULL;
48132 }
48133
48134
48135 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48136 PyObject *resultobj = 0;
48137 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48138 size_t arg2 ;
48139 int arg3 = (int) 0 ;
48140 void *argp1 = 0 ;
48141 int res1 = 0 ;
48142 size_t val2 ;
48143 int ecode2 = 0 ;
48144 int val3 ;
48145 int ecode3 = 0 ;
48146 PyObject * obj0 = 0 ;
48147 PyObject * obj1 = 0 ;
48148 PyObject * obj2 = 0 ;
48149 char * kwnames[] = {
48150 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48151 };
48152
48153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48155 if (!SWIG_IsOK(res1)) {
48156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48157 }
48158 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48159 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48160 if (!SWIG_IsOK(ecode2)) {
48161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48162 }
48163 arg2 = static_cast< size_t >(val2);
48164 if (obj2) {
48165 ecode3 = SWIG_AsVal_int(obj2, &val3);
48166 if (!SWIG_IsOK(ecode3)) {
48167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48168 }
48169 arg3 = static_cast< int >(val3);
48170 }
48171 {
48172 PyThreadState* __tstate = wxPyBeginAllowThreads();
48173 (arg1)->AddGrowableCol(arg2,arg3);
48174 wxPyEndAllowThreads(__tstate);
48175 if (PyErr_Occurred()) SWIG_fail;
48176 }
48177 resultobj = SWIG_Py_Void();
48178 return resultobj;
48179 fail:
48180 return NULL;
48181 }
48182
48183
48184 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48185 PyObject *resultobj = 0;
48186 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48187 size_t arg2 ;
48188 void *argp1 = 0 ;
48189 int res1 = 0 ;
48190 size_t val2 ;
48191 int ecode2 = 0 ;
48192 PyObject * obj0 = 0 ;
48193 PyObject * obj1 = 0 ;
48194 char * kwnames[] = {
48195 (char *) "self",(char *) "idx", NULL
48196 };
48197
48198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48200 if (!SWIG_IsOK(res1)) {
48201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48202 }
48203 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48204 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48205 if (!SWIG_IsOK(ecode2)) {
48206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48207 }
48208 arg2 = static_cast< size_t >(val2);
48209 {
48210 PyThreadState* __tstate = wxPyBeginAllowThreads();
48211 (arg1)->RemoveGrowableCol(arg2);
48212 wxPyEndAllowThreads(__tstate);
48213 if (PyErr_Occurred()) SWIG_fail;
48214 }
48215 resultobj = SWIG_Py_Void();
48216 return resultobj;
48217 fail:
48218 return NULL;
48219 }
48220
48221
48222 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48223 PyObject *resultobj = 0;
48224 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48225 int arg2 ;
48226 void *argp1 = 0 ;
48227 int res1 = 0 ;
48228 int val2 ;
48229 int ecode2 = 0 ;
48230 PyObject * obj0 = 0 ;
48231 PyObject * obj1 = 0 ;
48232 char * kwnames[] = {
48233 (char *) "self",(char *) "direction", NULL
48234 };
48235
48236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48238 if (!SWIG_IsOK(res1)) {
48239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48240 }
48241 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48242 ecode2 = SWIG_AsVal_int(obj1, &val2);
48243 if (!SWIG_IsOK(ecode2)) {
48244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48245 }
48246 arg2 = static_cast< int >(val2);
48247 {
48248 PyThreadState* __tstate = wxPyBeginAllowThreads();
48249 (arg1)->SetFlexibleDirection(arg2);
48250 wxPyEndAllowThreads(__tstate);
48251 if (PyErr_Occurred()) SWIG_fail;
48252 }
48253 resultobj = SWIG_Py_Void();
48254 return resultobj;
48255 fail:
48256 return NULL;
48257 }
48258
48259
48260 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48261 PyObject *resultobj = 0;
48262 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48263 int result;
48264 void *argp1 = 0 ;
48265 int res1 = 0 ;
48266 PyObject *swig_obj[1] ;
48267
48268 if (!args) SWIG_fail;
48269 swig_obj[0] = args;
48270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48271 if (!SWIG_IsOK(res1)) {
48272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48273 }
48274 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48275 {
48276 PyThreadState* __tstate = wxPyBeginAllowThreads();
48277 result = (int)(arg1)->GetFlexibleDirection();
48278 wxPyEndAllowThreads(__tstate);
48279 if (PyErr_Occurred()) SWIG_fail;
48280 }
48281 resultobj = SWIG_From_int(static_cast< int >(result));
48282 return resultobj;
48283 fail:
48284 return NULL;
48285 }
48286
48287
48288 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48289 PyObject *resultobj = 0;
48290 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48291 wxFlexSizerGrowMode arg2 ;
48292 void *argp1 = 0 ;
48293 int res1 = 0 ;
48294 int val2 ;
48295 int ecode2 = 0 ;
48296 PyObject * obj0 = 0 ;
48297 PyObject * obj1 = 0 ;
48298 char * kwnames[] = {
48299 (char *) "self",(char *) "mode", NULL
48300 };
48301
48302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48304 if (!SWIG_IsOK(res1)) {
48305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48306 }
48307 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48308 ecode2 = SWIG_AsVal_int(obj1, &val2);
48309 if (!SWIG_IsOK(ecode2)) {
48310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48311 }
48312 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48313 {
48314 PyThreadState* __tstate = wxPyBeginAllowThreads();
48315 (arg1)->SetNonFlexibleGrowMode(arg2);
48316 wxPyEndAllowThreads(__tstate);
48317 if (PyErr_Occurred()) SWIG_fail;
48318 }
48319 resultobj = SWIG_Py_Void();
48320 return resultobj;
48321 fail:
48322 return NULL;
48323 }
48324
48325
48326 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48327 PyObject *resultobj = 0;
48328 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48329 wxFlexSizerGrowMode result;
48330 void *argp1 = 0 ;
48331 int res1 = 0 ;
48332 PyObject *swig_obj[1] ;
48333
48334 if (!args) SWIG_fail;
48335 swig_obj[0] = args;
48336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48337 if (!SWIG_IsOK(res1)) {
48338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48339 }
48340 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48341 {
48342 PyThreadState* __tstate = wxPyBeginAllowThreads();
48343 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48344 wxPyEndAllowThreads(__tstate);
48345 if (PyErr_Occurred()) SWIG_fail;
48346 }
48347 resultobj = SWIG_From_int(static_cast< int >(result));
48348 return resultobj;
48349 fail:
48350 return NULL;
48351 }
48352
48353
48354 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48355 PyObject *resultobj = 0;
48356 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48357 wxArrayInt *result = 0 ;
48358 void *argp1 = 0 ;
48359 int res1 = 0 ;
48360 PyObject *swig_obj[1] ;
48361
48362 if (!args) SWIG_fail;
48363 swig_obj[0] = args;
48364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48365 if (!SWIG_IsOK(res1)) {
48366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48367 }
48368 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48369 {
48370 PyThreadState* __tstate = wxPyBeginAllowThreads();
48371 {
48372 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48373 result = (wxArrayInt *) &_result_ref;
48374 }
48375 wxPyEndAllowThreads(__tstate);
48376 if (PyErr_Occurred()) SWIG_fail;
48377 }
48378 {
48379 resultobj = PyList_New(0);
48380 size_t idx;
48381 for (idx = 0; idx < result->GetCount(); idx += 1) {
48382 PyObject* val = PyInt_FromLong( result->Item(idx) );
48383 PyList_Append(resultobj, val);
48384 Py_DECREF(val);
48385 }
48386 }
48387 return resultobj;
48388 fail:
48389 return NULL;
48390 }
48391
48392
48393 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48394 PyObject *resultobj = 0;
48395 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48396 wxArrayInt *result = 0 ;
48397 void *argp1 = 0 ;
48398 int res1 = 0 ;
48399 PyObject *swig_obj[1] ;
48400
48401 if (!args) SWIG_fail;
48402 swig_obj[0] = args;
48403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48404 if (!SWIG_IsOK(res1)) {
48405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48406 }
48407 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48408 {
48409 PyThreadState* __tstate = wxPyBeginAllowThreads();
48410 {
48411 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48412 result = (wxArrayInt *) &_result_ref;
48413 }
48414 wxPyEndAllowThreads(__tstate);
48415 if (PyErr_Occurred()) SWIG_fail;
48416 }
48417 {
48418 resultobj = PyList_New(0);
48419 size_t idx;
48420 for (idx = 0; idx < result->GetCount(); idx += 1) {
48421 PyObject* val = PyInt_FromLong( result->Item(idx) );
48422 PyList_Append(resultobj, val);
48423 Py_DECREF(val);
48424 }
48425 }
48426 return resultobj;
48427 fail:
48428 return NULL;
48429 }
48430
48431
48432 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48433 PyObject *obj;
48434 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48435 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48436 return SWIG_Py_Void();
48437 }
48438
48439 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48440 return SWIG_Python_InitShadowInstance(args);
48441 }
48442
48443 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48444 PyObject *resultobj = 0;
48445 wxStdDialogButtonSizer *result = 0 ;
48446
48447 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48448 {
48449 PyThreadState* __tstate = wxPyBeginAllowThreads();
48450 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48451 wxPyEndAllowThreads(__tstate);
48452 if (PyErr_Occurred()) SWIG_fail;
48453 }
48454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48455 return resultobj;
48456 fail:
48457 return NULL;
48458 }
48459
48460
48461 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48462 PyObject *resultobj = 0;
48463 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48464 wxButton *arg2 = (wxButton *) 0 ;
48465 void *argp1 = 0 ;
48466 int res1 = 0 ;
48467 void *argp2 = 0 ;
48468 int res2 = 0 ;
48469 PyObject * obj0 = 0 ;
48470 PyObject * obj1 = 0 ;
48471 char * kwnames[] = {
48472 (char *) "self",(char *) "button", NULL
48473 };
48474
48475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48477 if (!SWIG_IsOK(res1)) {
48478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48479 }
48480 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48481 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48482 if (!SWIG_IsOK(res2)) {
48483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48484 }
48485 arg2 = reinterpret_cast< wxButton * >(argp2);
48486 {
48487 PyThreadState* __tstate = wxPyBeginAllowThreads();
48488 (arg1)->AddButton(arg2);
48489 wxPyEndAllowThreads(__tstate);
48490 if (PyErr_Occurred()) SWIG_fail;
48491 }
48492 resultobj = SWIG_Py_Void();
48493 return resultobj;
48494 fail:
48495 return NULL;
48496 }
48497
48498
48499 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48500 PyObject *resultobj = 0;
48501 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48502 void *argp1 = 0 ;
48503 int res1 = 0 ;
48504 PyObject *swig_obj[1] ;
48505
48506 if (!args) SWIG_fail;
48507 swig_obj[0] = args;
48508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48509 if (!SWIG_IsOK(res1)) {
48510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48511 }
48512 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48513 {
48514 PyThreadState* __tstate = wxPyBeginAllowThreads();
48515 (arg1)->Realize();
48516 wxPyEndAllowThreads(__tstate);
48517 if (PyErr_Occurred()) SWIG_fail;
48518 }
48519 resultobj = SWIG_Py_Void();
48520 return resultobj;
48521 fail:
48522 return NULL;
48523 }
48524
48525
48526 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48527 PyObject *resultobj = 0;
48528 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48529 wxButton *arg2 = (wxButton *) 0 ;
48530 void *argp1 = 0 ;
48531 int res1 = 0 ;
48532 void *argp2 = 0 ;
48533 int res2 = 0 ;
48534 PyObject * obj0 = 0 ;
48535 PyObject * obj1 = 0 ;
48536 char * kwnames[] = {
48537 (char *) "self",(char *) "button", NULL
48538 };
48539
48540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48542 if (!SWIG_IsOK(res1)) {
48543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48544 }
48545 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48546 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48547 if (!SWIG_IsOK(res2)) {
48548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48549 }
48550 arg2 = reinterpret_cast< wxButton * >(argp2);
48551 {
48552 PyThreadState* __tstate = wxPyBeginAllowThreads();
48553 (arg1)->SetAffirmativeButton(arg2);
48554 wxPyEndAllowThreads(__tstate);
48555 if (PyErr_Occurred()) SWIG_fail;
48556 }
48557 resultobj = SWIG_Py_Void();
48558 return resultobj;
48559 fail:
48560 return NULL;
48561 }
48562
48563
48564 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48565 PyObject *resultobj = 0;
48566 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48567 wxButton *arg2 = (wxButton *) 0 ;
48568 void *argp1 = 0 ;
48569 int res1 = 0 ;
48570 void *argp2 = 0 ;
48571 int res2 = 0 ;
48572 PyObject * obj0 = 0 ;
48573 PyObject * obj1 = 0 ;
48574 char * kwnames[] = {
48575 (char *) "self",(char *) "button", NULL
48576 };
48577
48578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48580 if (!SWIG_IsOK(res1)) {
48581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48582 }
48583 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48584 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48585 if (!SWIG_IsOK(res2)) {
48586 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48587 }
48588 arg2 = reinterpret_cast< wxButton * >(argp2);
48589 {
48590 PyThreadState* __tstate = wxPyBeginAllowThreads();
48591 (arg1)->SetNegativeButton(arg2);
48592 wxPyEndAllowThreads(__tstate);
48593 if (PyErr_Occurred()) SWIG_fail;
48594 }
48595 resultobj = SWIG_Py_Void();
48596 return resultobj;
48597 fail:
48598 return NULL;
48599 }
48600
48601
48602 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48603 PyObject *resultobj = 0;
48604 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48605 wxButton *arg2 = (wxButton *) 0 ;
48606 void *argp1 = 0 ;
48607 int res1 = 0 ;
48608 void *argp2 = 0 ;
48609 int res2 = 0 ;
48610 PyObject * obj0 = 0 ;
48611 PyObject * obj1 = 0 ;
48612 char * kwnames[] = {
48613 (char *) "self",(char *) "button", NULL
48614 };
48615
48616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48618 if (!SWIG_IsOK(res1)) {
48619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48620 }
48621 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48622 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48623 if (!SWIG_IsOK(res2)) {
48624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48625 }
48626 arg2 = reinterpret_cast< wxButton * >(argp2);
48627 {
48628 PyThreadState* __tstate = wxPyBeginAllowThreads();
48629 (arg1)->SetCancelButton(arg2);
48630 wxPyEndAllowThreads(__tstate);
48631 if (PyErr_Occurred()) SWIG_fail;
48632 }
48633 resultobj = SWIG_Py_Void();
48634 return resultobj;
48635 fail:
48636 return NULL;
48637 }
48638
48639
48640 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48641 PyObject *resultobj = 0;
48642 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48643 wxButton *result = 0 ;
48644 void *argp1 = 0 ;
48645 int res1 = 0 ;
48646 PyObject *swig_obj[1] ;
48647
48648 if (!args) SWIG_fail;
48649 swig_obj[0] = args;
48650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48651 if (!SWIG_IsOK(res1)) {
48652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48653 }
48654 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48655 {
48656 PyThreadState* __tstate = wxPyBeginAllowThreads();
48657 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48658 wxPyEndAllowThreads(__tstate);
48659 if (PyErr_Occurred()) SWIG_fail;
48660 }
48661 {
48662 resultobj = wxPyMake_wxObject(result, (bool)0);
48663 }
48664 return resultobj;
48665 fail:
48666 return NULL;
48667 }
48668
48669
48670 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48671 PyObject *resultobj = 0;
48672 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48673 wxButton *result = 0 ;
48674 void *argp1 = 0 ;
48675 int res1 = 0 ;
48676 PyObject *swig_obj[1] ;
48677
48678 if (!args) SWIG_fail;
48679 swig_obj[0] = args;
48680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48681 if (!SWIG_IsOK(res1)) {
48682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48683 }
48684 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48685 {
48686 PyThreadState* __tstate = wxPyBeginAllowThreads();
48687 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48688 wxPyEndAllowThreads(__tstate);
48689 if (PyErr_Occurred()) SWIG_fail;
48690 }
48691 {
48692 resultobj = wxPyMake_wxObject(result, (bool)0);
48693 }
48694 return resultobj;
48695 fail:
48696 return NULL;
48697 }
48698
48699
48700 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48701 PyObject *resultobj = 0;
48702 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48703 wxButton *result = 0 ;
48704 void *argp1 = 0 ;
48705 int res1 = 0 ;
48706 PyObject *swig_obj[1] ;
48707
48708 if (!args) SWIG_fail;
48709 swig_obj[0] = args;
48710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48711 if (!SWIG_IsOK(res1)) {
48712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48713 }
48714 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48715 {
48716 PyThreadState* __tstate = wxPyBeginAllowThreads();
48717 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48718 wxPyEndAllowThreads(__tstate);
48719 if (PyErr_Occurred()) SWIG_fail;
48720 }
48721 {
48722 resultobj = wxPyMake_wxObject(result, (bool)0);
48723 }
48724 return resultobj;
48725 fail:
48726 return NULL;
48727 }
48728
48729
48730 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48731 PyObject *resultobj = 0;
48732 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48733 wxButton *result = 0 ;
48734 void *argp1 = 0 ;
48735 int res1 = 0 ;
48736 PyObject *swig_obj[1] ;
48737
48738 if (!args) SWIG_fail;
48739 swig_obj[0] = args;
48740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48741 if (!SWIG_IsOK(res1)) {
48742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48743 }
48744 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48745 {
48746 PyThreadState* __tstate = wxPyBeginAllowThreads();
48747 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48748 wxPyEndAllowThreads(__tstate);
48749 if (PyErr_Occurred()) SWIG_fail;
48750 }
48751 {
48752 resultobj = wxPyMake_wxObject(result, (bool)0);
48753 }
48754 return resultobj;
48755 fail:
48756 return NULL;
48757 }
48758
48759
48760 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48761 PyObject *resultobj = 0;
48762 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48763 wxButton *result = 0 ;
48764 void *argp1 = 0 ;
48765 int res1 = 0 ;
48766 PyObject *swig_obj[1] ;
48767
48768 if (!args) SWIG_fail;
48769 swig_obj[0] = args;
48770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48771 if (!SWIG_IsOK(res1)) {
48772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48773 }
48774 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48775 {
48776 PyThreadState* __tstate = wxPyBeginAllowThreads();
48777 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48778 wxPyEndAllowThreads(__tstate);
48779 if (PyErr_Occurred()) SWIG_fail;
48780 }
48781 {
48782 resultobj = wxPyMake_wxObject(result, (bool)0);
48783 }
48784 return resultobj;
48785 fail:
48786 return NULL;
48787 }
48788
48789
48790 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48791 PyObject *obj;
48792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48793 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48794 return SWIG_Py_Void();
48795 }
48796
48797 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48798 return SWIG_Python_InitShadowInstance(args);
48799 }
48800
48801 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48802 PyObject *resultobj = 0;
48803 int arg1 = (int) 0 ;
48804 int arg2 = (int) 0 ;
48805 wxGBPosition *result = 0 ;
48806 int val1 ;
48807 int ecode1 = 0 ;
48808 int val2 ;
48809 int ecode2 = 0 ;
48810 PyObject * obj0 = 0 ;
48811 PyObject * obj1 = 0 ;
48812 char * kwnames[] = {
48813 (char *) "row",(char *) "col", NULL
48814 };
48815
48816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48817 if (obj0) {
48818 ecode1 = SWIG_AsVal_int(obj0, &val1);
48819 if (!SWIG_IsOK(ecode1)) {
48820 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48821 }
48822 arg1 = static_cast< int >(val1);
48823 }
48824 if (obj1) {
48825 ecode2 = SWIG_AsVal_int(obj1, &val2);
48826 if (!SWIG_IsOK(ecode2)) {
48827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48828 }
48829 arg2 = static_cast< int >(val2);
48830 }
48831 {
48832 PyThreadState* __tstate = wxPyBeginAllowThreads();
48833 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48834 wxPyEndAllowThreads(__tstate);
48835 if (PyErr_Occurred()) SWIG_fail;
48836 }
48837 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48838 return resultobj;
48839 fail:
48840 return NULL;
48841 }
48842
48843
48844 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48845 PyObject *resultobj = 0;
48846 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48847 void *argp1 = 0 ;
48848 int res1 = 0 ;
48849 PyObject *swig_obj[1] ;
48850
48851 if (!args) SWIG_fail;
48852 swig_obj[0] = args;
48853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48854 if (!SWIG_IsOK(res1)) {
48855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48856 }
48857 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48858 {
48859 PyThreadState* __tstate = wxPyBeginAllowThreads();
48860 delete arg1;
48861
48862 wxPyEndAllowThreads(__tstate);
48863 if (PyErr_Occurred()) SWIG_fail;
48864 }
48865 resultobj = SWIG_Py_Void();
48866 return resultobj;
48867 fail:
48868 return NULL;
48869 }
48870
48871
48872 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48873 PyObject *resultobj = 0;
48874 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48875 int result;
48876 void *argp1 = 0 ;
48877 int res1 = 0 ;
48878 PyObject *swig_obj[1] ;
48879
48880 if (!args) SWIG_fail;
48881 swig_obj[0] = args;
48882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48883 if (!SWIG_IsOK(res1)) {
48884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48885 }
48886 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48887 {
48888 PyThreadState* __tstate = wxPyBeginAllowThreads();
48889 result = (int)((wxGBPosition const *)arg1)->GetRow();
48890 wxPyEndAllowThreads(__tstate);
48891 if (PyErr_Occurred()) SWIG_fail;
48892 }
48893 resultobj = SWIG_From_int(static_cast< int >(result));
48894 return resultobj;
48895 fail:
48896 return NULL;
48897 }
48898
48899
48900 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48901 PyObject *resultobj = 0;
48902 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48903 int result;
48904 void *argp1 = 0 ;
48905 int res1 = 0 ;
48906 PyObject *swig_obj[1] ;
48907
48908 if (!args) SWIG_fail;
48909 swig_obj[0] = args;
48910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48911 if (!SWIG_IsOK(res1)) {
48912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48913 }
48914 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48915 {
48916 PyThreadState* __tstate = wxPyBeginAllowThreads();
48917 result = (int)((wxGBPosition const *)arg1)->GetCol();
48918 wxPyEndAllowThreads(__tstate);
48919 if (PyErr_Occurred()) SWIG_fail;
48920 }
48921 resultobj = SWIG_From_int(static_cast< int >(result));
48922 return resultobj;
48923 fail:
48924 return NULL;
48925 }
48926
48927
48928 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48929 PyObject *resultobj = 0;
48930 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48931 int arg2 ;
48932 void *argp1 = 0 ;
48933 int res1 = 0 ;
48934 int val2 ;
48935 int ecode2 = 0 ;
48936 PyObject * obj0 = 0 ;
48937 PyObject * obj1 = 0 ;
48938 char * kwnames[] = {
48939 (char *) "self",(char *) "row", NULL
48940 };
48941
48942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48944 if (!SWIG_IsOK(res1)) {
48945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48946 }
48947 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48948 ecode2 = SWIG_AsVal_int(obj1, &val2);
48949 if (!SWIG_IsOK(ecode2)) {
48950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48951 }
48952 arg2 = static_cast< int >(val2);
48953 {
48954 PyThreadState* __tstate = wxPyBeginAllowThreads();
48955 (arg1)->SetRow(arg2);
48956 wxPyEndAllowThreads(__tstate);
48957 if (PyErr_Occurred()) SWIG_fail;
48958 }
48959 resultobj = SWIG_Py_Void();
48960 return resultobj;
48961 fail:
48962 return NULL;
48963 }
48964
48965
48966 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48967 PyObject *resultobj = 0;
48968 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48969 int arg2 ;
48970 void *argp1 = 0 ;
48971 int res1 = 0 ;
48972 int val2 ;
48973 int ecode2 = 0 ;
48974 PyObject * obj0 = 0 ;
48975 PyObject * obj1 = 0 ;
48976 char * kwnames[] = {
48977 (char *) "self",(char *) "col", NULL
48978 };
48979
48980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48982 if (!SWIG_IsOK(res1)) {
48983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48984 }
48985 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48986 ecode2 = SWIG_AsVal_int(obj1, &val2);
48987 if (!SWIG_IsOK(ecode2)) {
48988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48989 }
48990 arg2 = static_cast< int >(val2);
48991 {
48992 PyThreadState* __tstate = wxPyBeginAllowThreads();
48993 (arg1)->SetCol(arg2);
48994 wxPyEndAllowThreads(__tstate);
48995 if (PyErr_Occurred()) SWIG_fail;
48996 }
48997 resultobj = SWIG_Py_Void();
48998 return resultobj;
48999 fail:
49000 return NULL;
49001 }
49002
49003
49004 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49005 PyObject *resultobj = 0;
49006 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49007 PyObject *arg2 = (PyObject *) 0 ;
49008 bool result;
49009 void *argp1 = 0 ;
49010 int res1 = 0 ;
49011 PyObject * obj0 = 0 ;
49012 PyObject * obj1 = 0 ;
49013 char * kwnames[] = {
49014 (char *) "self",(char *) "other", NULL
49015 };
49016
49017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49019 if (!SWIG_IsOK(res1)) {
49020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49021 }
49022 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49023 arg2 = obj1;
49024 {
49025 result = (bool)wxGBPosition___eq__(arg1,arg2);
49026 if (PyErr_Occurred()) SWIG_fail;
49027 }
49028 {
49029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49030 }
49031 return resultobj;
49032 fail:
49033 return NULL;
49034 }
49035
49036
49037 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49038 PyObject *resultobj = 0;
49039 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49040 PyObject *arg2 = (PyObject *) 0 ;
49041 bool result;
49042 void *argp1 = 0 ;
49043 int res1 = 0 ;
49044 PyObject * obj0 = 0 ;
49045 PyObject * obj1 = 0 ;
49046 char * kwnames[] = {
49047 (char *) "self",(char *) "other", NULL
49048 };
49049
49050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49052 if (!SWIG_IsOK(res1)) {
49053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49054 }
49055 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49056 arg2 = obj1;
49057 {
49058 result = (bool)wxGBPosition___ne__(arg1,arg2);
49059 if (PyErr_Occurred()) SWIG_fail;
49060 }
49061 {
49062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49063 }
49064 return resultobj;
49065 fail:
49066 return NULL;
49067 }
49068
49069
49070 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49071 PyObject *resultobj = 0;
49072 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49073 int arg2 = (int) 0 ;
49074 int arg3 = (int) 0 ;
49075 void *argp1 = 0 ;
49076 int res1 = 0 ;
49077 int val2 ;
49078 int ecode2 = 0 ;
49079 int val3 ;
49080 int ecode3 = 0 ;
49081 PyObject * obj0 = 0 ;
49082 PyObject * obj1 = 0 ;
49083 PyObject * obj2 = 0 ;
49084 char * kwnames[] = {
49085 (char *) "self",(char *) "row",(char *) "col", NULL
49086 };
49087
49088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49090 if (!SWIG_IsOK(res1)) {
49091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49092 }
49093 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49094 if (obj1) {
49095 ecode2 = SWIG_AsVal_int(obj1, &val2);
49096 if (!SWIG_IsOK(ecode2)) {
49097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49098 }
49099 arg2 = static_cast< int >(val2);
49100 }
49101 if (obj2) {
49102 ecode3 = SWIG_AsVal_int(obj2, &val3);
49103 if (!SWIG_IsOK(ecode3)) {
49104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49105 }
49106 arg3 = static_cast< int >(val3);
49107 }
49108 {
49109 PyThreadState* __tstate = wxPyBeginAllowThreads();
49110 wxGBPosition_Set(arg1,arg2,arg3);
49111 wxPyEndAllowThreads(__tstate);
49112 if (PyErr_Occurred()) SWIG_fail;
49113 }
49114 resultobj = SWIG_Py_Void();
49115 return resultobj;
49116 fail:
49117 return NULL;
49118 }
49119
49120
49121 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49122 PyObject *resultobj = 0;
49123 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49124 PyObject *result = 0 ;
49125 void *argp1 = 0 ;
49126 int res1 = 0 ;
49127 PyObject *swig_obj[1] ;
49128
49129 if (!args) SWIG_fail;
49130 swig_obj[0] = args;
49131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49132 if (!SWIG_IsOK(res1)) {
49133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49134 }
49135 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49136 {
49137 PyThreadState* __tstate = wxPyBeginAllowThreads();
49138 result = (PyObject *)wxGBPosition_Get(arg1);
49139 wxPyEndAllowThreads(__tstate);
49140 if (PyErr_Occurred()) SWIG_fail;
49141 }
49142 resultobj = result;
49143 return resultobj;
49144 fail:
49145 return NULL;
49146 }
49147
49148
49149 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49150 PyObject *obj;
49151 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49152 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49153 return SWIG_Py_Void();
49154 }
49155
49156 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49157 return SWIG_Python_InitShadowInstance(args);
49158 }
49159
49160 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49161 PyObject *resultobj = 0;
49162 int arg1 = (int) 1 ;
49163 int arg2 = (int) 1 ;
49164 wxGBSpan *result = 0 ;
49165 int val1 ;
49166 int ecode1 = 0 ;
49167 int val2 ;
49168 int ecode2 = 0 ;
49169 PyObject * obj0 = 0 ;
49170 PyObject * obj1 = 0 ;
49171 char * kwnames[] = {
49172 (char *) "rowspan",(char *) "colspan", NULL
49173 };
49174
49175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49176 if (obj0) {
49177 ecode1 = SWIG_AsVal_int(obj0, &val1);
49178 if (!SWIG_IsOK(ecode1)) {
49179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49180 }
49181 arg1 = static_cast< int >(val1);
49182 }
49183 if (obj1) {
49184 ecode2 = SWIG_AsVal_int(obj1, &val2);
49185 if (!SWIG_IsOK(ecode2)) {
49186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49187 }
49188 arg2 = static_cast< int >(val2);
49189 }
49190 {
49191 PyThreadState* __tstate = wxPyBeginAllowThreads();
49192 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49193 wxPyEndAllowThreads(__tstate);
49194 if (PyErr_Occurred()) SWIG_fail;
49195 }
49196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49197 return resultobj;
49198 fail:
49199 return NULL;
49200 }
49201
49202
49203 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49204 PyObject *resultobj = 0;
49205 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49206 void *argp1 = 0 ;
49207 int res1 = 0 ;
49208 PyObject *swig_obj[1] ;
49209
49210 if (!args) SWIG_fail;
49211 swig_obj[0] = args;
49212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49213 if (!SWIG_IsOK(res1)) {
49214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49215 }
49216 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49217 {
49218 PyThreadState* __tstate = wxPyBeginAllowThreads();
49219 delete arg1;
49220
49221 wxPyEndAllowThreads(__tstate);
49222 if (PyErr_Occurred()) SWIG_fail;
49223 }
49224 resultobj = SWIG_Py_Void();
49225 return resultobj;
49226 fail:
49227 return NULL;
49228 }
49229
49230
49231 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49232 PyObject *resultobj = 0;
49233 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49234 int result;
49235 void *argp1 = 0 ;
49236 int res1 = 0 ;
49237 PyObject *swig_obj[1] ;
49238
49239 if (!args) SWIG_fail;
49240 swig_obj[0] = args;
49241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49242 if (!SWIG_IsOK(res1)) {
49243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49244 }
49245 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49246 {
49247 PyThreadState* __tstate = wxPyBeginAllowThreads();
49248 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49249 wxPyEndAllowThreads(__tstate);
49250 if (PyErr_Occurred()) SWIG_fail;
49251 }
49252 resultobj = SWIG_From_int(static_cast< int >(result));
49253 return resultobj;
49254 fail:
49255 return NULL;
49256 }
49257
49258
49259 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49260 PyObject *resultobj = 0;
49261 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49262 int result;
49263 void *argp1 = 0 ;
49264 int res1 = 0 ;
49265 PyObject *swig_obj[1] ;
49266
49267 if (!args) SWIG_fail;
49268 swig_obj[0] = args;
49269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49270 if (!SWIG_IsOK(res1)) {
49271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49272 }
49273 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49274 {
49275 PyThreadState* __tstate = wxPyBeginAllowThreads();
49276 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49277 wxPyEndAllowThreads(__tstate);
49278 if (PyErr_Occurred()) SWIG_fail;
49279 }
49280 resultobj = SWIG_From_int(static_cast< int >(result));
49281 return resultobj;
49282 fail:
49283 return NULL;
49284 }
49285
49286
49287 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49288 PyObject *resultobj = 0;
49289 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49290 int arg2 ;
49291 void *argp1 = 0 ;
49292 int res1 = 0 ;
49293 int val2 ;
49294 int ecode2 = 0 ;
49295 PyObject * obj0 = 0 ;
49296 PyObject * obj1 = 0 ;
49297 char * kwnames[] = {
49298 (char *) "self",(char *) "rowspan", NULL
49299 };
49300
49301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49303 if (!SWIG_IsOK(res1)) {
49304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49305 }
49306 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49307 ecode2 = SWIG_AsVal_int(obj1, &val2);
49308 if (!SWIG_IsOK(ecode2)) {
49309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49310 }
49311 arg2 = static_cast< int >(val2);
49312 {
49313 PyThreadState* __tstate = wxPyBeginAllowThreads();
49314 (arg1)->SetRowspan(arg2);
49315 wxPyEndAllowThreads(__tstate);
49316 if (PyErr_Occurred()) SWIG_fail;
49317 }
49318 resultobj = SWIG_Py_Void();
49319 return resultobj;
49320 fail:
49321 return NULL;
49322 }
49323
49324
49325 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49326 PyObject *resultobj = 0;
49327 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49328 int arg2 ;
49329 void *argp1 = 0 ;
49330 int res1 = 0 ;
49331 int val2 ;
49332 int ecode2 = 0 ;
49333 PyObject * obj0 = 0 ;
49334 PyObject * obj1 = 0 ;
49335 char * kwnames[] = {
49336 (char *) "self",(char *) "colspan", NULL
49337 };
49338
49339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49341 if (!SWIG_IsOK(res1)) {
49342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49343 }
49344 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49345 ecode2 = SWIG_AsVal_int(obj1, &val2);
49346 if (!SWIG_IsOK(ecode2)) {
49347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49348 }
49349 arg2 = static_cast< int >(val2);
49350 {
49351 PyThreadState* __tstate = wxPyBeginAllowThreads();
49352 (arg1)->SetColspan(arg2);
49353 wxPyEndAllowThreads(__tstate);
49354 if (PyErr_Occurred()) SWIG_fail;
49355 }
49356 resultobj = SWIG_Py_Void();
49357 return resultobj;
49358 fail:
49359 return NULL;
49360 }
49361
49362
49363 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49364 PyObject *resultobj = 0;
49365 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49366 PyObject *arg2 = (PyObject *) 0 ;
49367 bool result;
49368 void *argp1 = 0 ;
49369 int res1 = 0 ;
49370 PyObject * obj0 = 0 ;
49371 PyObject * obj1 = 0 ;
49372 char * kwnames[] = {
49373 (char *) "self",(char *) "other", NULL
49374 };
49375
49376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49378 if (!SWIG_IsOK(res1)) {
49379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49380 }
49381 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49382 arg2 = obj1;
49383 {
49384 result = (bool)wxGBSpan___eq__(arg1,arg2);
49385 if (PyErr_Occurred()) SWIG_fail;
49386 }
49387 {
49388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49389 }
49390 return resultobj;
49391 fail:
49392 return NULL;
49393 }
49394
49395
49396 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49397 PyObject *resultobj = 0;
49398 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49399 PyObject *arg2 = (PyObject *) 0 ;
49400 bool result;
49401 void *argp1 = 0 ;
49402 int res1 = 0 ;
49403 PyObject * obj0 = 0 ;
49404 PyObject * obj1 = 0 ;
49405 char * kwnames[] = {
49406 (char *) "self",(char *) "other", NULL
49407 };
49408
49409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49411 if (!SWIG_IsOK(res1)) {
49412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49413 }
49414 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49415 arg2 = obj1;
49416 {
49417 result = (bool)wxGBSpan___ne__(arg1,arg2);
49418 if (PyErr_Occurred()) SWIG_fail;
49419 }
49420 {
49421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49422 }
49423 return resultobj;
49424 fail:
49425 return NULL;
49426 }
49427
49428
49429 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49430 PyObject *resultobj = 0;
49431 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49432 int arg2 = (int) 1 ;
49433 int arg3 = (int) 1 ;
49434 void *argp1 = 0 ;
49435 int res1 = 0 ;
49436 int val2 ;
49437 int ecode2 = 0 ;
49438 int val3 ;
49439 int ecode3 = 0 ;
49440 PyObject * obj0 = 0 ;
49441 PyObject * obj1 = 0 ;
49442 PyObject * obj2 = 0 ;
49443 char * kwnames[] = {
49444 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49445 };
49446
49447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49449 if (!SWIG_IsOK(res1)) {
49450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49451 }
49452 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49453 if (obj1) {
49454 ecode2 = SWIG_AsVal_int(obj1, &val2);
49455 if (!SWIG_IsOK(ecode2)) {
49456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49457 }
49458 arg2 = static_cast< int >(val2);
49459 }
49460 if (obj2) {
49461 ecode3 = SWIG_AsVal_int(obj2, &val3);
49462 if (!SWIG_IsOK(ecode3)) {
49463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49464 }
49465 arg3 = static_cast< int >(val3);
49466 }
49467 {
49468 PyThreadState* __tstate = wxPyBeginAllowThreads();
49469 wxGBSpan_Set(arg1,arg2,arg3);
49470 wxPyEndAllowThreads(__tstate);
49471 if (PyErr_Occurred()) SWIG_fail;
49472 }
49473 resultobj = SWIG_Py_Void();
49474 return resultobj;
49475 fail:
49476 return NULL;
49477 }
49478
49479
49480 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49481 PyObject *resultobj = 0;
49482 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49483 PyObject *result = 0 ;
49484 void *argp1 = 0 ;
49485 int res1 = 0 ;
49486 PyObject *swig_obj[1] ;
49487
49488 if (!args) SWIG_fail;
49489 swig_obj[0] = args;
49490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49491 if (!SWIG_IsOK(res1)) {
49492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49493 }
49494 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49495 {
49496 PyThreadState* __tstate = wxPyBeginAllowThreads();
49497 result = (PyObject *)wxGBSpan_Get(arg1);
49498 wxPyEndAllowThreads(__tstate);
49499 if (PyErr_Occurred()) SWIG_fail;
49500 }
49501 resultobj = result;
49502 return resultobj;
49503 fail:
49504 return NULL;
49505 }
49506
49507
49508 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49509 PyObject *obj;
49510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49511 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49512 return SWIG_Py_Void();
49513 }
49514
49515 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49516 return SWIG_Python_InitShadowInstance(args);
49517 }
49518
49519 SWIGINTERN int DefaultSpan_set(PyObject *) {
49520 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49521 return 1;
49522 }
49523
49524
49525 SWIGINTERN PyObject *DefaultSpan_get(void) {
49526 PyObject *pyobj = 0;
49527
49528 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49529 return pyobj;
49530 }
49531
49532
49533 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49534 PyObject *resultobj = 0;
49535 wxGBSizerItem *result = 0 ;
49536
49537 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49538 {
49539 PyThreadState* __tstate = wxPyBeginAllowThreads();
49540 result = (wxGBSizerItem *)new wxGBSizerItem();
49541 wxPyEndAllowThreads(__tstate);
49542 if (PyErr_Occurred()) SWIG_fail;
49543 }
49544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49545 return resultobj;
49546 fail:
49547 return NULL;
49548 }
49549
49550
49551 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49552 PyObject *resultobj = 0;
49553 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49554 void *argp1 = 0 ;
49555 int res1 = 0 ;
49556 PyObject *swig_obj[1] ;
49557
49558 if (!args) SWIG_fail;
49559 swig_obj[0] = args;
49560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49561 if (!SWIG_IsOK(res1)) {
49562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49563 }
49564 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49565 {
49566 PyThreadState* __tstate = wxPyBeginAllowThreads();
49567 delete arg1;
49568
49569 wxPyEndAllowThreads(__tstate);
49570 if (PyErr_Occurred()) SWIG_fail;
49571 }
49572 resultobj = SWIG_Py_Void();
49573 return resultobj;
49574 fail:
49575 return NULL;
49576 }
49577
49578
49579 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49580 PyObject *resultobj = 0;
49581 wxWindow *arg1 = (wxWindow *) 0 ;
49582 wxGBPosition *arg2 = 0 ;
49583 wxGBSpan *arg3 = 0 ;
49584 int arg4 ;
49585 int arg5 ;
49586 PyObject *arg6 = (PyObject *) NULL ;
49587 wxGBSizerItem *result = 0 ;
49588 void *argp1 = 0 ;
49589 int res1 = 0 ;
49590 wxGBPosition temp2 ;
49591 wxGBSpan temp3 ;
49592 int val4 ;
49593 int ecode4 = 0 ;
49594 int val5 ;
49595 int ecode5 = 0 ;
49596 PyObject * obj0 = 0 ;
49597 PyObject * obj1 = 0 ;
49598 PyObject * obj2 = 0 ;
49599 PyObject * obj3 = 0 ;
49600 PyObject * obj4 = 0 ;
49601 PyObject * obj5 = 0 ;
49602 char * kwnames[] = {
49603 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49604 };
49605
49606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49608 if (!SWIG_IsOK(res1)) {
49609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49610 }
49611 arg1 = reinterpret_cast< wxWindow * >(argp1);
49612 {
49613 arg2 = &temp2;
49614 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49615 }
49616 {
49617 arg3 = &temp3;
49618 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49619 }
49620 ecode4 = SWIG_AsVal_int(obj3, &val4);
49621 if (!SWIG_IsOK(ecode4)) {
49622 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49623 }
49624 arg4 = static_cast< int >(val4);
49625 ecode5 = SWIG_AsVal_int(obj4, &val5);
49626 if (!SWIG_IsOK(ecode5)) {
49627 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49628 }
49629 arg5 = static_cast< int >(val5);
49630 if (obj5) {
49631 arg6 = obj5;
49632 }
49633 {
49634 PyThreadState* __tstate = wxPyBeginAllowThreads();
49635 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49636 wxPyEndAllowThreads(__tstate);
49637 if (PyErr_Occurred()) SWIG_fail;
49638 }
49639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49640 return resultobj;
49641 fail:
49642 return NULL;
49643 }
49644
49645
49646 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49647 PyObject *resultobj = 0;
49648 wxSizer *arg1 = (wxSizer *) 0 ;
49649 wxGBPosition *arg2 = 0 ;
49650 wxGBSpan *arg3 = 0 ;
49651 int arg4 ;
49652 int arg5 ;
49653 PyObject *arg6 = (PyObject *) NULL ;
49654 wxGBSizerItem *result = 0 ;
49655 int res1 = 0 ;
49656 wxGBPosition temp2 ;
49657 wxGBSpan temp3 ;
49658 int val4 ;
49659 int ecode4 = 0 ;
49660 int val5 ;
49661 int ecode5 = 0 ;
49662 PyObject * obj0 = 0 ;
49663 PyObject * obj1 = 0 ;
49664 PyObject * obj2 = 0 ;
49665 PyObject * obj3 = 0 ;
49666 PyObject * obj4 = 0 ;
49667 PyObject * obj5 = 0 ;
49668 char * kwnames[] = {
49669 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49670 };
49671
49672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49673 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49674 if (!SWIG_IsOK(res1)) {
49675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49676 }
49677 {
49678 arg2 = &temp2;
49679 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49680 }
49681 {
49682 arg3 = &temp3;
49683 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49684 }
49685 ecode4 = SWIG_AsVal_int(obj3, &val4);
49686 if (!SWIG_IsOK(ecode4)) {
49687 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49688 }
49689 arg4 = static_cast< int >(val4);
49690 ecode5 = SWIG_AsVal_int(obj4, &val5);
49691 if (!SWIG_IsOK(ecode5)) {
49692 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49693 }
49694 arg5 = static_cast< int >(val5);
49695 if (obj5) {
49696 arg6 = obj5;
49697 }
49698 {
49699 PyThreadState* __tstate = wxPyBeginAllowThreads();
49700 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49701 wxPyEndAllowThreads(__tstate);
49702 if (PyErr_Occurred()) SWIG_fail;
49703 }
49704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49705 return resultobj;
49706 fail:
49707 return NULL;
49708 }
49709
49710
49711 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49712 PyObject *resultobj = 0;
49713 int arg1 ;
49714 int arg2 ;
49715 wxGBPosition *arg3 = 0 ;
49716 wxGBSpan *arg4 = 0 ;
49717 int arg5 ;
49718 int arg6 ;
49719 PyObject *arg7 = (PyObject *) NULL ;
49720 wxGBSizerItem *result = 0 ;
49721 int val1 ;
49722 int ecode1 = 0 ;
49723 int val2 ;
49724 int ecode2 = 0 ;
49725 wxGBPosition temp3 ;
49726 wxGBSpan temp4 ;
49727 int val5 ;
49728 int ecode5 = 0 ;
49729 int val6 ;
49730 int ecode6 = 0 ;
49731 PyObject * obj0 = 0 ;
49732 PyObject * obj1 = 0 ;
49733 PyObject * obj2 = 0 ;
49734 PyObject * obj3 = 0 ;
49735 PyObject * obj4 = 0 ;
49736 PyObject * obj5 = 0 ;
49737 PyObject * obj6 = 0 ;
49738 char * kwnames[] = {
49739 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49740 };
49741
49742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49743 ecode1 = SWIG_AsVal_int(obj0, &val1);
49744 if (!SWIG_IsOK(ecode1)) {
49745 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49746 }
49747 arg1 = static_cast< int >(val1);
49748 ecode2 = SWIG_AsVal_int(obj1, &val2);
49749 if (!SWIG_IsOK(ecode2)) {
49750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49751 }
49752 arg2 = static_cast< int >(val2);
49753 {
49754 arg3 = &temp3;
49755 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49756 }
49757 {
49758 arg4 = &temp4;
49759 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49760 }
49761 ecode5 = SWIG_AsVal_int(obj4, &val5);
49762 if (!SWIG_IsOK(ecode5)) {
49763 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49764 }
49765 arg5 = static_cast< int >(val5);
49766 ecode6 = SWIG_AsVal_int(obj5, &val6);
49767 if (!SWIG_IsOK(ecode6)) {
49768 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49769 }
49770 arg6 = static_cast< int >(val6);
49771 if (obj6) {
49772 arg7 = obj6;
49773 }
49774 {
49775 PyThreadState* __tstate = wxPyBeginAllowThreads();
49776 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49777 wxPyEndAllowThreads(__tstate);
49778 if (PyErr_Occurred()) SWIG_fail;
49779 }
49780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49781 return resultobj;
49782 fail:
49783 return NULL;
49784 }
49785
49786
49787 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49788 PyObject *resultobj = 0;
49789 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49790 wxGBPosition result;
49791 void *argp1 = 0 ;
49792 int res1 = 0 ;
49793 PyObject *swig_obj[1] ;
49794
49795 if (!args) SWIG_fail;
49796 swig_obj[0] = args;
49797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49798 if (!SWIG_IsOK(res1)) {
49799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49800 }
49801 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49802 {
49803 PyThreadState* __tstate = wxPyBeginAllowThreads();
49804 result = ((wxGBSizerItem const *)arg1)->GetPos();
49805 wxPyEndAllowThreads(__tstate);
49806 if (PyErr_Occurred()) SWIG_fail;
49807 }
49808 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49809 return resultobj;
49810 fail:
49811 return NULL;
49812 }
49813
49814
49815 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49816 PyObject *resultobj = 0;
49817 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49818 wxGBSpan result;
49819 void *argp1 = 0 ;
49820 int res1 = 0 ;
49821 PyObject *swig_obj[1] ;
49822
49823 if (!args) SWIG_fail;
49824 swig_obj[0] = args;
49825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49826 if (!SWIG_IsOK(res1)) {
49827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49828 }
49829 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49830 {
49831 PyThreadState* __tstate = wxPyBeginAllowThreads();
49832 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49833 wxPyEndAllowThreads(__tstate);
49834 if (PyErr_Occurred()) SWIG_fail;
49835 }
49836 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49837 return resultobj;
49838 fail:
49839 return NULL;
49840 }
49841
49842
49843 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49844 PyObject *resultobj = 0;
49845 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49846 wxGBPosition *arg2 = 0 ;
49847 bool result;
49848 void *argp1 = 0 ;
49849 int res1 = 0 ;
49850 wxGBPosition temp2 ;
49851 PyObject * obj0 = 0 ;
49852 PyObject * obj1 = 0 ;
49853 char * kwnames[] = {
49854 (char *) "self",(char *) "pos", NULL
49855 };
49856
49857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49859 if (!SWIG_IsOK(res1)) {
49860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49861 }
49862 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49863 {
49864 arg2 = &temp2;
49865 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49866 }
49867 {
49868 PyThreadState* __tstate = wxPyBeginAllowThreads();
49869 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49870 wxPyEndAllowThreads(__tstate);
49871 if (PyErr_Occurred()) SWIG_fail;
49872 }
49873 {
49874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49875 }
49876 return resultobj;
49877 fail:
49878 return NULL;
49879 }
49880
49881
49882 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49883 PyObject *resultobj = 0;
49884 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49885 wxGBSpan *arg2 = 0 ;
49886 bool result;
49887 void *argp1 = 0 ;
49888 int res1 = 0 ;
49889 wxGBSpan temp2 ;
49890 PyObject * obj0 = 0 ;
49891 PyObject * obj1 = 0 ;
49892 char * kwnames[] = {
49893 (char *) "self",(char *) "span", NULL
49894 };
49895
49896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49898 if (!SWIG_IsOK(res1)) {
49899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49900 }
49901 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49902 {
49903 arg2 = &temp2;
49904 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49905 }
49906 {
49907 PyThreadState* __tstate = wxPyBeginAllowThreads();
49908 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49909 wxPyEndAllowThreads(__tstate);
49910 if (PyErr_Occurred()) SWIG_fail;
49911 }
49912 {
49913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49914 }
49915 return resultobj;
49916 fail:
49917 return NULL;
49918 }
49919
49920
49921 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49922 PyObject *resultobj = 0;
49923 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49924 wxGBSizerItem *arg2 = 0 ;
49925 bool result;
49926 void *argp1 = 0 ;
49927 int res1 = 0 ;
49928 void *argp2 = 0 ;
49929 int res2 = 0 ;
49930 PyObject * obj0 = 0 ;
49931 PyObject * obj1 = 0 ;
49932 char * kwnames[] = {
49933 (char *) "self",(char *) "other", NULL
49934 };
49935
49936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49938 if (!SWIG_IsOK(res1)) {
49939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49940 }
49941 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49942 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49943 if (!SWIG_IsOK(res2)) {
49944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49945 }
49946 if (!argp2) {
49947 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49948 }
49949 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49950 {
49951 PyThreadState* __tstate = wxPyBeginAllowThreads();
49952 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49953 wxPyEndAllowThreads(__tstate);
49954 if (PyErr_Occurred()) SWIG_fail;
49955 }
49956 {
49957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49958 }
49959 return resultobj;
49960 fail:
49961 return NULL;
49962 }
49963
49964
49965 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49966 PyObject *resultobj = 0;
49967 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49968 wxGBPosition *arg2 = 0 ;
49969 wxGBSpan *arg3 = 0 ;
49970 bool result;
49971 void *argp1 = 0 ;
49972 int res1 = 0 ;
49973 wxGBPosition temp2 ;
49974 wxGBSpan temp3 ;
49975 PyObject * obj0 = 0 ;
49976 PyObject * obj1 = 0 ;
49977 PyObject * obj2 = 0 ;
49978 char * kwnames[] = {
49979 (char *) "self",(char *) "pos",(char *) "span", NULL
49980 };
49981
49982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49984 if (!SWIG_IsOK(res1)) {
49985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49986 }
49987 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49988 {
49989 arg2 = &temp2;
49990 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49991 }
49992 {
49993 arg3 = &temp3;
49994 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49995 }
49996 {
49997 PyThreadState* __tstate = wxPyBeginAllowThreads();
49998 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49999 wxPyEndAllowThreads(__tstate);
50000 if (PyErr_Occurred()) SWIG_fail;
50001 }
50002 {
50003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50004 }
50005 return resultobj;
50006 fail:
50007 return NULL;
50008 }
50009
50010
50011 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50012 PyObject *resultobj = 0;
50013 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50014 wxGBPosition result;
50015 void *argp1 = 0 ;
50016 int res1 = 0 ;
50017 PyObject *swig_obj[1] ;
50018
50019 if (!args) SWIG_fail;
50020 swig_obj[0] = args;
50021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50022 if (!SWIG_IsOK(res1)) {
50023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50024 }
50025 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50026 {
50027 PyThreadState* __tstate = wxPyBeginAllowThreads();
50028 result = wxGBSizerItem_GetEndPos(arg1);
50029 wxPyEndAllowThreads(__tstate);
50030 if (PyErr_Occurred()) SWIG_fail;
50031 }
50032 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50033 return resultobj;
50034 fail:
50035 return NULL;
50036 }
50037
50038
50039 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50040 PyObject *resultobj = 0;
50041 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50042 wxGridBagSizer *result = 0 ;
50043 void *argp1 = 0 ;
50044 int res1 = 0 ;
50045 PyObject *swig_obj[1] ;
50046
50047 if (!args) SWIG_fail;
50048 swig_obj[0] = args;
50049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50050 if (!SWIG_IsOK(res1)) {
50051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50052 }
50053 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50054 {
50055 PyThreadState* __tstate = wxPyBeginAllowThreads();
50056 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50057 wxPyEndAllowThreads(__tstate);
50058 if (PyErr_Occurred()) SWIG_fail;
50059 }
50060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50061 return resultobj;
50062 fail:
50063 return NULL;
50064 }
50065
50066
50067 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50068 PyObject *resultobj = 0;
50069 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50070 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50071 void *argp1 = 0 ;
50072 int res1 = 0 ;
50073 void *argp2 = 0 ;
50074 int res2 = 0 ;
50075 PyObject * obj0 = 0 ;
50076 PyObject * obj1 = 0 ;
50077 char * kwnames[] = {
50078 (char *) "self",(char *) "sizer", NULL
50079 };
50080
50081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50083 if (!SWIG_IsOK(res1)) {
50084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50085 }
50086 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50087 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50088 if (!SWIG_IsOK(res2)) {
50089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50090 }
50091 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50092 {
50093 PyThreadState* __tstate = wxPyBeginAllowThreads();
50094 (arg1)->SetGBSizer(arg2);
50095 wxPyEndAllowThreads(__tstate);
50096 if (PyErr_Occurred()) SWIG_fail;
50097 }
50098 resultobj = SWIG_Py_Void();
50099 return resultobj;
50100 fail:
50101 return NULL;
50102 }
50103
50104
50105 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50106 PyObject *obj;
50107 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50108 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50109 return SWIG_Py_Void();
50110 }
50111
50112 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50113 return SWIG_Python_InitShadowInstance(args);
50114 }
50115
50116 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50117 PyObject *resultobj = 0;
50118 int arg1 = (int) 0 ;
50119 int arg2 = (int) 0 ;
50120 wxGridBagSizer *result = 0 ;
50121 int val1 ;
50122 int ecode1 = 0 ;
50123 int val2 ;
50124 int ecode2 = 0 ;
50125 PyObject * obj0 = 0 ;
50126 PyObject * obj1 = 0 ;
50127 char * kwnames[] = {
50128 (char *) "vgap",(char *) "hgap", NULL
50129 };
50130
50131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50132 if (obj0) {
50133 ecode1 = SWIG_AsVal_int(obj0, &val1);
50134 if (!SWIG_IsOK(ecode1)) {
50135 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50136 }
50137 arg1 = static_cast< int >(val1);
50138 }
50139 if (obj1) {
50140 ecode2 = SWIG_AsVal_int(obj1, &val2);
50141 if (!SWIG_IsOK(ecode2)) {
50142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50143 }
50144 arg2 = static_cast< int >(val2);
50145 }
50146 {
50147 PyThreadState* __tstate = wxPyBeginAllowThreads();
50148 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50149 wxPyEndAllowThreads(__tstate);
50150 if (PyErr_Occurred()) SWIG_fail;
50151 }
50152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50153 return resultobj;
50154 fail:
50155 return NULL;
50156 }
50157
50158
50159 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50160 PyObject *resultobj = 0;
50161 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50162 PyObject *arg2 = (PyObject *) 0 ;
50163 wxGBPosition *arg3 = 0 ;
50164 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50165 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50166 int arg5 = (int) 0 ;
50167 int arg6 = (int) 0 ;
50168 PyObject *arg7 = (PyObject *) NULL ;
50169 wxGBSizerItem *result = 0 ;
50170 void *argp1 = 0 ;
50171 int res1 = 0 ;
50172 wxGBPosition temp3 ;
50173 wxGBSpan temp4 ;
50174 int val5 ;
50175 int ecode5 = 0 ;
50176 int val6 ;
50177 int ecode6 = 0 ;
50178 PyObject * obj0 = 0 ;
50179 PyObject * obj1 = 0 ;
50180 PyObject * obj2 = 0 ;
50181 PyObject * obj3 = 0 ;
50182 PyObject * obj4 = 0 ;
50183 PyObject * obj5 = 0 ;
50184 PyObject * obj6 = 0 ;
50185 char * kwnames[] = {
50186 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50187 };
50188
50189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50191 if (!SWIG_IsOK(res1)) {
50192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50193 }
50194 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50195 arg2 = obj1;
50196 {
50197 arg3 = &temp3;
50198 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50199 }
50200 if (obj3) {
50201 {
50202 arg4 = &temp4;
50203 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50204 }
50205 }
50206 if (obj4) {
50207 ecode5 = SWIG_AsVal_int(obj4, &val5);
50208 if (!SWIG_IsOK(ecode5)) {
50209 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50210 }
50211 arg5 = static_cast< int >(val5);
50212 }
50213 if (obj5) {
50214 ecode6 = SWIG_AsVal_int(obj5, &val6);
50215 if (!SWIG_IsOK(ecode6)) {
50216 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50217 }
50218 arg6 = static_cast< int >(val6);
50219 }
50220 if (obj6) {
50221 arg7 = obj6;
50222 }
50223 {
50224 PyThreadState* __tstate = wxPyBeginAllowThreads();
50225 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50226 wxPyEndAllowThreads(__tstate);
50227 if (PyErr_Occurred()) SWIG_fail;
50228 }
50229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50230 return resultobj;
50231 fail:
50232 return NULL;
50233 }
50234
50235
50236 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50237 PyObject *resultobj = 0;
50238 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50239 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50240 wxGBSizerItem *result = 0 ;
50241 void *argp1 = 0 ;
50242 int res1 = 0 ;
50243 int res2 = 0 ;
50244 PyObject * obj0 = 0 ;
50245 PyObject * obj1 = 0 ;
50246 char * kwnames[] = {
50247 (char *) "self",(char *) "item", NULL
50248 };
50249
50250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50252 if (!SWIG_IsOK(res1)) {
50253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50254 }
50255 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50256 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50257 if (!SWIG_IsOK(res2)) {
50258 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50259 }
50260 {
50261 PyThreadState* __tstate = wxPyBeginAllowThreads();
50262 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50263 wxPyEndAllowThreads(__tstate);
50264 if (PyErr_Occurred()) SWIG_fail;
50265 }
50266 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50267 return resultobj;
50268 fail:
50269 return NULL;
50270 }
50271
50272
50273 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50274 PyObject *resultobj = 0;
50275 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50276 int arg2 ;
50277 int arg3 ;
50278 wxSize result;
50279 void *argp1 = 0 ;
50280 int res1 = 0 ;
50281 int val2 ;
50282 int ecode2 = 0 ;
50283 int val3 ;
50284 int ecode3 = 0 ;
50285 PyObject * obj0 = 0 ;
50286 PyObject * obj1 = 0 ;
50287 PyObject * obj2 = 0 ;
50288 char * kwnames[] = {
50289 (char *) "self",(char *) "row",(char *) "col", NULL
50290 };
50291
50292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50294 if (!SWIG_IsOK(res1)) {
50295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50296 }
50297 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50298 ecode2 = SWIG_AsVal_int(obj1, &val2);
50299 if (!SWIG_IsOK(ecode2)) {
50300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50301 }
50302 arg2 = static_cast< int >(val2);
50303 ecode3 = SWIG_AsVal_int(obj2, &val3);
50304 if (!SWIG_IsOK(ecode3)) {
50305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50306 }
50307 arg3 = static_cast< int >(val3);
50308 {
50309 PyThreadState* __tstate = wxPyBeginAllowThreads();
50310 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50311 wxPyEndAllowThreads(__tstate);
50312 if (PyErr_Occurred()) SWIG_fail;
50313 }
50314 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50315 return resultobj;
50316 fail:
50317 return NULL;
50318 }
50319
50320
50321 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50322 PyObject *resultobj = 0;
50323 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50324 wxSize result;
50325 void *argp1 = 0 ;
50326 int res1 = 0 ;
50327 PyObject *swig_obj[1] ;
50328
50329 if (!args) SWIG_fail;
50330 swig_obj[0] = args;
50331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50332 if (!SWIG_IsOK(res1)) {
50333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50334 }
50335 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50336 {
50337 PyThreadState* __tstate = wxPyBeginAllowThreads();
50338 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50339 wxPyEndAllowThreads(__tstate);
50340 if (PyErr_Occurred()) SWIG_fail;
50341 }
50342 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50343 return resultobj;
50344 fail:
50345 return NULL;
50346 }
50347
50348
50349 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50350 PyObject *resultobj = 0;
50351 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50352 wxSize *arg2 = 0 ;
50353 void *argp1 = 0 ;
50354 int res1 = 0 ;
50355 wxSize temp2 ;
50356 PyObject * obj0 = 0 ;
50357 PyObject * obj1 = 0 ;
50358 char * kwnames[] = {
50359 (char *) "self",(char *) "sz", NULL
50360 };
50361
50362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50364 if (!SWIG_IsOK(res1)) {
50365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50366 }
50367 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50368 {
50369 arg2 = &temp2;
50370 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50371 }
50372 {
50373 PyThreadState* __tstate = wxPyBeginAllowThreads();
50374 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50375 wxPyEndAllowThreads(__tstate);
50376 if (PyErr_Occurred()) SWIG_fail;
50377 }
50378 resultobj = SWIG_Py_Void();
50379 return resultobj;
50380 fail:
50381 return NULL;
50382 }
50383
50384
50385 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50386 PyObject *resultobj = 0;
50387 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50388 wxWindow *arg2 = (wxWindow *) 0 ;
50389 wxGBPosition result;
50390 void *argp1 = 0 ;
50391 int res1 = 0 ;
50392 void *argp2 = 0 ;
50393 int res2 = 0 ;
50394
50395 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50397 if (!SWIG_IsOK(res1)) {
50398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50399 }
50400 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50401 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50402 if (!SWIG_IsOK(res2)) {
50403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50404 }
50405 arg2 = reinterpret_cast< wxWindow * >(argp2);
50406 {
50407 PyThreadState* __tstate = wxPyBeginAllowThreads();
50408 result = (arg1)->GetItemPosition(arg2);
50409 wxPyEndAllowThreads(__tstate);
50410 if (PyErr_Occurred()) SWIG_fail;
50411 }
50412 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50413 return resultobj;
50414 fail:
50415 return NULL;
50416 }
50417
50418
50419 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50420 PyObject *resultobj = 0;
50421 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50422 wxSizer *arg2 = (wxSizer *) 0 ;
50423 wxGBPosition result;
50424 void *argp1 = 0 ;
50425 int res1 = 0 ;
50426 void *argp2 = 0 ;
50427 int res2 = 0 ;
50428
50429 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50431 if (!SWIG_IsOK(res1)) {
50432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50433 }
50434 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50435 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50436 if (!SWIG_IsOK(res2)) {
50437 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50438 }
50439 arg2 = reinterpret_cast< wxSizer * >(argp2);
50440 {
50441 PyThreadState* __tstate = wxPyBeginAllowThreads();
50442 result = (arg1)->GetItemPosition(arg2);
50443 wxPyEndAllowThreads(__tstate);
50444 if (PyErr_Occurred()) SWIG_fail;
50445 }
50446 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50447 return resultobj;
50448 fail:
50449 return NULL;
50450 }
50451
50452
50453 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50454 PyObject *resultobj = 0;
50455 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50456 size_t arg2 ;
50457 wxGBPosition result;
50458 void *argp1 = 0 ;
50459 int res1 = 0 ;
50460 size_t val2 ;
50461 int ecode2 = 0 ;
50462
50463 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50465 if (!SWIG_IsOK(res1)) {
50466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50467 }
50468 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50469 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50470 if (!SWIG_IsOK(ecode2)) {
50471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50472 }
50473 arg2 = static_cast< size_t >(val2);
50474 {
50475 PyThreadState* __tstate = wxPyBeginAllowThreads();
50476 result = (arg1)->GetItemPosition(arg2);
50477 wxPyEndAllowThreads(__tstate);
50478 if (PyErr_Occurred()) SWIG_fail;
50479 }
50480 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50481 return resultobj;
50482 fail:
50483 return NULL;
50484 }
50485
50486
50487 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50488 int argc;
50489 PyObject *argv[3];
50490
50491 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50492 --argc;
50493 if (argc == 2) {
50494 int _v = 0;
50495 {
50496 void *vptr = 0;
50497 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50498 _v = SWIG_CheckState(res);
50499 }
50500 if (!_v) goto check_1;
50501 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50502 }
50503 check_1:
50504
50505 if (argc == 2) {
50506 int _v = 0;
50507 {
50508 void *vptr = 0;
50509 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50510 _v = SWIG_CheckState(res);
50511 }
50512 if (!_v) goto check_2;
50513 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50514 }
50515 check_2:
50516
50517 if (argc == 2) {
50518 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50519 }
50520
50521 fail:
50522 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50523 return NULL;
50524 }
50525
50526
50527 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50528 PyObject *resultobj = 0;
50529 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50530 wxWindow *arg2 = (wxWindow *) 0 ;
50531 wxGBPosition *arg3 = 0 ;
50532 bool result;
50533 void *argp1 = 0 ;
50534 int res1 = 0 ;
50535 void *argp2 = 0 ;
50536 int res2 = 0 ;
50537 wxGBPosition temp3 ;
50538
50539 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50541 if (!SWIG_IsOK(res1)) {
50542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50543 }
50544 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50545 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50546 if (!SWIG_IsOK(res2)) {
50547 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50548 }
50549 arg2 = reinterpret_cast< wxWindow * >(argp2);
50550 {
50551 arg3 = &temp3;
50552 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50553 }
50554 {
50555 PyThreadState* __tstate = wxPyBeginAllowThreads();
50556 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50557 wxPyEndAllowThreads(__tstate);
50558 if (PyErr_Occurred()) SWIG_fail;
50559 }
50560 {
50561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50562 }
50563 return resultobj;
50564 fail:
50565 return NULL;
50566 }
50567
50568
50569 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50570 PyObject *resultobj = 0;
50571 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50572 wxSizer *arg2 = (wxSizer *) 0 ;
50573 wxGBPosition *arg3 = 0 ;
50574 bool result;
50575 void *argp1 = 0 ;
50576 int res1 = 0 ;
50577 void *argp2 = 0 ;
50578 int res2 = 0 ;
50579 wxGBPosition temp3 ;
50580
50581 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50583 if (!SWIG_IsOK(res1)) {
50584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50585 }
50586 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50587 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50588 if (!SWIG_IsOK(res2)) {
50589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50590 }
50591 arg2 = reinterpret_cast< wxSizer * >(argp2);
50592 {
50593 arg3 = &temp3;
50594 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50595 }
50596 {
50597 PyThreadState* __tstate = wxPyBeginAllowThreads();
50598 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50599 wxPyEndAllowThreads(__tstate);
50600 if (PyErr_Occurred()) SWIG_fail;
50601 }
50602 {
50603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50604 }
50605 return resultobj;
50606 fail:
50607 return NULL;
50608 }
50609
50610
50611 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50612 PyObject *resultobj = 0;
50613 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50614 size_t arg2 ;
50615 wxGBPosition *arg3 = 0 ;
50616 bool result;
50617 void *argp1 = 0 ;
50618 int res1 = 0 ;
50619 size_t val2 ;
50620 int ecode2 = 0 ;
50621 wxGBPosition temp3 ;
50622
50623 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50625 if (!SWIG_IsOK(res1)) {
50626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50627 }
50628 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50629 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50630 if (!SWIG_IsOK(ecode2)) {
50631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50632 }
50633 arg2 = static_cast< size_t >(val2);
50634 {
50635 arg3 = &temp3;
50636 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50637 }
50638 {
50639 PyThreadState* __tstate = wxPyBeginAllowThreads();
50640 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50641 wxPyEndAllowThreads(__tstate);
50642 if (PyErr_Occurred()) SWIG_fail;
50643 }
50644 {
50645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50646 }
50647 return resultobj;
50648 fail:
50649 return NULL;
50650 }
50651
50652
50653 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50654 int argc;
50655 PyObject *argv[4];
50656
50657 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50658 --argc;
50659 if (argc == 3) {
50660 int _v = 0;
50661 {
50662 void *vptr = 0;
50663 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50664 _v = SWIG_CheckState(res);
50665 }
50666 if (!_v) goto check_1;
50667 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50668 }
50669 check_1:
50670
50671 if (argc == 3) {
50672 int _v = 0;
50673 {
50674 void *vptr = 0;
50675 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50676 _v = SWIG_CheckState(res);
50677 }
50678 if (!_v) goto check_2;
50679 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50680 }
50681 check_2:
50682
50683 if (argc == 3) {
50684 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50685 }
50686
50687 fail:
50688 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50689 return NULL;
50690 }
50691
50692
50693 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50694 PyObject *resultobj = 0;
50695 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50696 wxWindow *arg2 = (wxWindow *) 0 ;
50697 wxGBSpan result;
50698 void *argp1 = 0 ;
50699 int res1 = 0 ;
50700 void *argp2 = 0 ;
50701 int res2 = 0 ;
50702
50703 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50705 if (!SWIG_IsOK(res1)) {
50706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50707 }
50708 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50709 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50710 if (!SWIG_IsOK(res2)) {
50711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50712 }
50713 arg2 = reinterpret_cast< wxWindow * >(argp2);
50714 {
50715 PyThreadState* __tstate = wxPyBeginAllowThreads();
50716 result = (arg1)->GetItemSpan(arg2);
50717 wxPyEndAllowThreads(__tstate);
50718 if (PyErr_Occurred()) SWIG_fail;
50719 }
50720 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50721 return resultobj;
50722 fail:
50723 return NULL;
50724 }
50725
50726
50727 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50728 PyObject *resultobj = 0;
50729 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50730 wxSizer *arg2 = (wxSizer *) 0 ;
50731 wxGBSpan result;
50732 void *argp1 = 0 ;
50733 int res1 = 0 ;
50734 void *argp2 = 0 ;
50735 int res2 = 0 ;
50736
50737 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50739 if (!SWIG_IsOK(res1)) {
50740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50741 }
50742 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50743 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50744 if (!SWIG_IsOK(res2)) {
50745 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50746 }
50747 arg2 = reinterpret_cast< wxSizer * >(argp2);
50748 {
50749 PyThreadState* __tstate = wxPyBeginAllowThreads();
50750 result = (arg1)->GetItemSpan(arg2);
50751 wxPyEndAllowThreads(__tstate);
50752 if (PyErr_Occurred()) SWIG_fail;
50753 }
50754 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50755 return resultobj;
50756 fail:
50757 return NULL;
50758 }
50759
50760
50761 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50762 PyObject *resultobj = 0;
50763 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50764 size_t arg2 ;
50765 wxGBSpan result;
50766 void *argp1 = 0 ;
50767 int res1 = 0 ;
50768 size_t val2 ;
50769 int ecode2 = 0 ;
50770
50771 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50773 if (!SWIG_IsOK(res1)) {
50774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50775 }
50776 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50777 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50778 if (!SWIG_IsOK(ecode2)) {
50779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50780 }
50781 arg2 = static_cast< size_t >(val2);
50782 {
50783 PyThreadState* __tstate = wxPyBeginAllowThreads();
50784 result = (arg1)->GetItemSpan(arg2);
50785 wxPyEndAllowThreads(__tstate);
50786 if (PyErr_Occurred()) SWIG_fail;
50787 }
50788 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50789 return resultobj;
50790 fail:
50791 return NULL;
50792 }
50793
50794
50795 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50796 int argc;
50797 PyObject *argv[3];
50798
50799 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50800 --argc;
50801 if (argc == 2) {
50802 int _v = 0;
50803 {
50804 void *vptr = 0;
50805 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50806 _v = SWIG_CheckState(res);
50807 }
50808 if (!_v) goto check_1;
50809 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50810 }
50811 check_1:
50812
50813 if (argc == 2) {
50814 int _v = 0;
50815 {
50816 void *vptr = 0;
50817 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50818 _v = SWIG_CheckState(res);
50819 }
50820 if (!_v) goto check_2;
50821 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50822 }
50823 check_2:
50824
50825 if (argc == 2) {
50826 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50827 }
50828
50829 fail:
50830 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50831 return NULL;
50832 }
50833
50834
50835 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50836 PyObject *resultobj = 0;
50837 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50838 wxWindow *arg2 = (wxWindow *) 0 ;
50839 wxGBSpan *arg3 = 0 ;
50840 bool result;
50841 void *argp1 = 0 ;
50842 int res1 = 0 ;
50843 void *argp2 = 0 ;
50844 int res2 = 0 ;
50845 wxGBSpan temp3 ;
50846
50847 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50849 if (!SWIG_IsOK(res1)) {
50850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50851 }
50852 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50853 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50854 if (!SWIG_IsOK(res2)) {
50855 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50856 }
50857 arg2 = reinterpret_cast< wxWindow * >(argp2);
50858 {
50859 arg3 = &temp3;
50860 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50861 }
50862 {
50863 PyThreadState* __tstate = wxPyBeginAllowThreads();
50864 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50865 wxPyEndAllowThreads(__tstate);
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_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50878 PyObject *resultobj = 0;
50879 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50880 wxSizer *arg2 = (wxSizer *) 0 ;
50881 wxGBSpan *arg3 = 0 ;
50882 bool result;
50883 void *argp1 = 0 ;
50884 int res1 = 0 ;
50885 void *argp2 = 0 ;
50886 int res2 = 0 ;
50887 wxGBSpan temp3 ;
50888
50889 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50891 if (!SWIG_IsOK(res1)) {
50892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50893 }
50894 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50895 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50896 if (!SWIG_IsOK(res2)) {
50897 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50898 }
50899 arg2 = reinterpret_cast< wxSizer * >(argp2);
50900 {
50901 arg3 = &temp3;
50902 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50903 }
50904 {
50905 PyThreadState* __tstate = wxPyBeginAllowThreads();
50906 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50907 wxPyEndAllowThreads(__tstate);
50908 if (PyErr_Occurred()) SWIG_fail;
50909 }
50910 {
50911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50912 }
50913 return resultobj;
50914 fail:
50915 return NULL;
50916 }
50917
50918
50919 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50920 PyObject *resultobj = 0;
50921 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50922 size_t arg2 ;
50923 wxGBSpan *arg3 = 0 ;
50924 bool result;
50925 void *argp1 = 0 ;
50926 int res1 = 0 ;
50927 size_t val2 ;
50928 int ecode2 = 0 ;
50929 wxGBSpan temp3 ;
50930
50931 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50933 if (!SWIG_IsOK(res1)) {
50934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50935 }
50936 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50937 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50938 if (!SWIG_IsOK(ecode2)) {
50939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50940 }
50941 arg2 = static_cast< size_t >(val2);
50942 {
50943 arg3 = &temp3;
50944 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50945 }
50946 {
50947 PyThreadState* __tstate = wxPyBeginAllowThreads();
50948 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50949 wxPyEndAllowThreads(__tstate);
50950 if (PyErr_Occurred()) SWIG_fail;
50951 }
50952 {
50953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50954 }
50955 return resultobj;
50956 fail:
50957 return NULL;
50958 }
50959
50960
50961 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50962 int argc;
50963 PyObject *argv[4];
50964
50965 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50966 --argc;
50967 if (argc == 3) {
50968 int _v = 0;
50969 {
50970 void *vptr = 0;
50971 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50972 _v = SWIG_CheckState(res);
50973 }
50974 if (!_v) goto check_1;
50975 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50976 }
50977 check_1:
50978
50979 if (argc == 3) {
50980 int _v = 0;
50981 {
50982 void *vptr = 0;
50983 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50984 _v = SWIG_CheckState(res);
50985 }
50986 if (!_v) goto check_2;
50987 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50988 }
50989 check_2:
50990
50991 if (argc == 3) {
50992 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50993 }
50994
50995 fail:
50996 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50997 return NULL;
50998 }
50999
51000
51001 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51002 PyObject *resultobj = 0;
51003 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51004 wxWindow *arg2 = (wxWindow *) 0 ;
51005 wxGBSizerItem *result = 0 ;
51006 void *argp1 = 0 ;
51007 int res1 = 0 ;
51008 void *argp2 = 0 ;
51009 int res2 = 0 ;
51010
51011 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51013 if (!SWIG_IsOK(res1)) {
51014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51015 }
51016 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51017 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51018 if (!SWIG_IsOK(res2)) {
51019 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51020 }
51021 arg2 = reinterpret_cast< wxWindow * >(argp2);
51022 {
51023 PyThreadState* __tstate = wxPyBeginAllowThreads();
51024 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51025 wxPyEndAllowThreads(__tstate);
51026 if (PyErr_Occurred()) SWIG_fail;
51027 }
51028 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51029 return resultobj;
51030 fail:
51031 return NULL;
51032 }
51033
51034
51035 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51036 PyObject *resultobj = 0;
51037 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51038 wxSizer *arg2 = (wxSizer *) 0 ;
51039 wxGBSizerItem *result = 0 ;
51040 void *argp1 = 0 ;
51041 int res1 = 0 ;
51042 void *argp2 = 0 ;
51043 int res2 = 0 ;
51044
51045 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51047 if (!SWIG_IsOK(res1)) {
51048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51049 }
51050 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51051 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51052 if (!SWIG_IsOK(res2)) {
51053 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51054 }
51055 arg2 = reinterpret_cast< wxSizer * >(argp2);
51056 {
51057 PyThreadState* __tstate = wxPyBeginAllowThreads();
51058 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51059 wxPyEndAllowThreads(__tstate);
51060 if (PyErr_Occurred()) SWIG_fail;
51061 }
51062 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51063 return resultobj;
51064 fail:
51065 return NULL;
51066 }
51067
51068
51069 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51070 int argc;
51071 PyObject *argv[3];
51072
51073 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51074 --argc;
51075 if (argc == 2) {
51076 int _v = 0;
51077 {
51078 void *vptr = 0;
51079 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51080 _v = SWIG_CheckState(res);
51081 }
51082 if (!_v) goto check_1;
51083 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51084 }
51085 check_1:
51086
51087 if (argc == 2) {
51088 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51089 }
51090
51091 fail:
51092 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51093 return NULL;
51094 }
51095
51096
51097 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51098 PyObject *resultobj = 0;
51099 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51100 wxGBPosition *arg2 = 0 ;
51101 wxGBSizerItem *result = 0 ;
51102 void *argp1 = 0 ;
51103 int res1 = 0 ;
51104 wxGBPosition temp2 ;
51105 PyObject * obj0 = 0 ;
51106 PyObject * obj1 = 0 ;
51107 char * kwnames[] = {
51108 (char *) "self",(char *) "pos", NULL
51109 };
51110
51111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51113 if (!SWIG_IsOK(res1)) {
51114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51115 }
51116 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51117 {
51118 arg2 = &temp2;
51119 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51120 }
51121 {
51122 PyThreadState* __tstate = wxPyBeginAllowThreads();
51123 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51124 wxPyEndAllowThreads(__tstate);
51125 if (PyErr_Occurred()) SWIG_fail;
51126 }
51127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51128 return resultobj;
51129 fail:
51130 return NULL;
51131 }
51132
51133
51134 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51135 PyObject *resultobj = 0;
51136 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51137 wxPoint *arg2 = 0 ;
51138 wxGBSizerItem *result = 0 ;
51139 void *argp1 = 0 ;
51140 int res1 = 0 ;
51141 wxPoint temp2 ;
51142 PyObject * obj0 = 0 ;
51143 PyObject * obj1 = 0 ;
51144 char * kwnames[] = {
51145 (char *) "self",(char *) "pt", NULL
51146 };
51147
51148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51150 if (!SWIG_IsOK(res1)) {
51151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51152 }
51153 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51154 {
51155 arg2 = &temp2;
51156 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51157 }
51158 {
51159 PyThreadState* __tstate = wxPyBeginAllowThreads();
51160 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51161 wxPyEndAllowThreads(__tstate);
51162 if (PyErr_Occurred()) SWIG_fail;
51163 }
51164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51165 return resultobj;
51166 fail:
51167 return NULL;
51168 }
51169
51170
51171 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51172 PyObject *resultobj = 0;
51173 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51174 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51175 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51176 bool result;
51177 void *argp1 = 0 ;
51178 int res1 = 0 ;
51179 void *argp2 = 0 ;
51180 int res2 = 0 ;
51181 void *argp3 = 0 ;
51182 int res3 = 0 ;
51183 PyObject * obj0 = 0 ;
51184 PyObject * obj1 = 0 ;
51185 PyObject * obj2 = 0 ;
51186 char * kwnames[] = {
51187 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51188 };
51189
51190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51192 if (!SWIG_IsOK(res1)) {
51193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51194 }
51195 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51196 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51197 if (!SWIG_IsOK(res2)) {
51198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51199 }
51200 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51201 if (obj2) {
51202 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51203 if (!SWIG_IsOK(res3)) {
51204 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51205 }
51206 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51207 }
51208 {
51209 PyThreadState* __tstate = wxPyBeginAllowThreads();
51210 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51211 wxPyEndAllowThreads(__tstate);
51212 if (PyErr_Occurred()) SWIG_fail;
51213 }
51214 {
51215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51216 }
51217 return resultobj;
51218 fail:
51219 return NULL;
51220 }
51221
51222
51223 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51224 PyObject *resultobj = 0;
51225 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51226 wxGBPosition *arg2 = 0 ;
51227 wxGBSpan *arg3 = 0 ;
51228 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51229 bool result;
51230 void *argp1 = 0 ;
51231 int res1 = 0 ;
51232 wxGBPosition temp2 ;
51233 wxGBSpan temp3 ;
51234 void *argp4 = 0 ;
51235 int res4 = 0 ;
51236 PyObject * obj0 = 0 ;
51237 PyObject * obj1 = 0 ;
51238 PyObject * obj2 = 0 ;
51239 PyObject * obj3 = 0 ;
51240 char * kwnames[] = {
51241 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51242 };
51243
51244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51246 if (!SWIG_IsOK(res1)) {
51247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51248 }
51249 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51250 {
51251 arg2 = &temp2;
51252 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51253 }
51254 {
51255 arg3 = &temp3;
51256 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51257 }
51258 if (obj3) {
51259 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51260 if (!SWIG_IsOK(res4)) {
51261 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51262 }
51263 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51264 }
51265 {
51266 PyThreadState* __tstate = wxPyBeginAllowThreads();
51267 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51268 wxPyEndAllowThreads(__tstate);
51269 if (PyErr_Occurred()) SWIG_fail;
51270 }
51271 {
51272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51273 }
51274 return resultobj;
51275 fail:
51276 return NULL;
51277 }
51278
51279
51280 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51281 PyObject *obj;
51282 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51283 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51284 return SWIG_Py_Void();
51285 }
51286
51287 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51288 return SWIG_Python_InitShadowInstance(args);
51289 }
51290
51291 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51292 PyObject *resultobj = 0;
51293 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51294 wxRelationship arg2 ;
51295 wxWindow *arg3 = (wxWindow *) 0 ;
51296 wxEdge arg4 ;
51297 int arg5 = (int) 0 ;
51298 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51299 void *argp1 = 0 ;
51300 int res1 = 0 ;
51301 int val2 ;
51302 int ecode2 = 0 ;
51303 void *argp3 = 0 ;
51304 int res3 = 0 ;
51305 int val4 ;
51306 int ecode4 = 0 ;
51307 int val5 ;
51308 int ecode5 = 0 ;
51309 int val6 ;
51310 int ecode6 = 0 ;
51311 PyObject * obj0 = 0 ;
51312 PyObject * obj1 = 0 ;
51313 PyObject * obj2 = 0 ;
51314 PyObject * obj3 = 0 ;
51315 PyObject * obj4 = 0 ;
51316 PyObject * obj5 = 0 ;
51317 char * kwnames[] = {
51318 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51319 };
51320
51321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51323 if (!SWIG_IsOK(res1)) {
51324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51325 }
51326 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51327 ecode2 = SWIG_AsVal_int(obj1, &val2);
51328 if (!SWIG_IsOK(ecode2)) {
51329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51330 }
51331 arg2 = static_cast< wxRelationship >(val2);
51332 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51333 if (!SWIG_IsOK(res3)) {
51334 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51335 }
51336 arg3 = reinterpret_cast< wxWindow * >(argp3);
51337 ecode4 = SWIG_AsVal_int(obj3, &val4);
51338 if (!SWIG_IsOK(ecode4)) {
51339 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51340 }
51341 arg4 = static_cast< wxEdge >(val4);
51342 if (obj4) {
51343 ecode5 = SWIG_AsVal_int(obj4, &val5);
51344 if (!SWIG_IsOK(ecode5)) {
51345 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51346 }
51347 arg5 = static_cast< int >(val5);
51348 }
51349 if (obj5) {
51350 ecode6 = SWIG_AsVal_int(obj5, &val6);
51351 if (!SWIG_IsOK(ecode6)) {
51352 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51353 }
51354 arg6 = static_cast< int >(val6);
51355 }
51356 {
51357 PyThreadState* __tstate = wxPyBeginAllowThreads();
51358 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51359 wxPyEndAllowThreads(__tstate);
51360 if (PyErr_Occurred()) SWIG_fail;
51361 }
51362 resultobj = SWIG_Py_Void();
51363 return resultobj;
51364 fail:
51365 return NULL;
51366 }
51367
51368
51369 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51370 PyObject *resultobj = 0;
51371 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51372 wxWindow *arg2 = (wxWindow *) 0 ;
51373 int arg3 = (int) 0 ;
51374 void *argp1 = 0 ;
51375 int res1 = 0 ;
51376 void *argp2 = 0 ;
51377 int res2 = 0 ;
51378 int val3 ;
51379 int ecode3 = 0 ;
51380 PyObject * obj0 = 0 ;
51381 PyObject * obj1 = 0 ;
51382 PyObject * obj2 = 0 ;
51383 char * kwnames[] = {
51384 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51385 };
51386
51387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51389 if (!SWIG_IsOK(res1)) {
51390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51391 }
51392 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51393 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51394 if (!SWIG_IsOK(res2)) {
51395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51396 }
51397 arg2 = reinterpret_cast< wxWindow * >(argp2);
51398 if (obj2) {
51399 ecode3 = SWIG_AsVal_int(obj2, &val3);
51400 if (!SWIG_IsOK(ecode3)) {
51401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51402 }
51403 arg3 = static_cast< int >(val3);
51404 }
51405 {
51406 PyThreadState* __tstate = wxPyBeginAllowThreads();
51407 (arg1)->LeftOf(arg2,arg3);
51408 wxPyEndAllowThreads(__tstate);
51409 if (PyErr_Occurred()) SWIG_fail;
51410 }
51411 resultobj = SWIG_Py_Void();
51412 return resultobj;
51413 fail:
51414 return NULL;
51415 }
51416
51417
51418 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51419 PyObject *resultobj = 0;
51420 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51421 wxWindow *arg2 = (wxWindow *) 0 ;
51422 int arg3 = (int) 0 ;
51423 void *argp1 = 0 ;
51424 int res1 = 0 ;
51425 void *argp2 = 0 ;
51426 int res2 = 0 ;
51427 int val3 ;
51428 int ecode3 = 0 ;
51429 PyObject * obj0 = 0 ;
51430 PyObject * obj1 = 0 ;
51431 PyObject * obj2 = 0 ;
51432 char * kwnames[] = {
51433 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51434 };
51435
51436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51438 if (!SWIG_IsOK(res1)) {
51439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51440 }
51441 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51442 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51443 if (!SWIG_IsOK(res2)) {
51444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51445 }
51446 arg2 = reinterpret_cast< wxWindow * >(argp2);
51447 if (obj2) {
51448 ecode3 = SWIG_AsVal_int(obj2, &val3);
51449 if (!SWIG_IsOK(ecode3)) {
51450 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51451 }
51452 arg3 = static_cast< int >(val3);
51453 }
51454 {
51455 PyThreadState* __tstate = wxPyBeginAllowThreads();
51456 (arg1)->RightOf(arg2,arg3);
51457 wxPyEndAllowThreads(__tstate);
51458 if (PyErr_Occurred()) SWIG_fail;
51459 }
51460 resultobj = SWIG_Py_Void();
51461 return resultobj;
51462 fail:
51463 return NULL;
51464 }
51465
51466
51467 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51468 PyObject *resultobj = 0;
51469 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51470 wxWindow *arg2 = (wxWindow *) 0 ;
51471 int arg3 = (int) 0 ;
51472 void *argp1 = 0 ;
51473 int res1 = 0 ;
51474 void *argp2 = 0 ;
51475 int res2 = 0 ;
51476 int val3 ;
51477 int ecode3 = 0 ;
51478 PyObject * obj0 = 0 ;
51479 PyObject * obj1 = 0 ;
51480 PyObject * obj2 = 0 ;
51481 char * kwnames[] = {
51482 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51483 };
51484
51485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51487 if (!SWIG_IsOK(res1)) {
51488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51489 }
51490 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51491 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51492 if (!SWIG_IsOK(res2)) {
51493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51494 }
51495 arg2 = reinterpret_cast< wxWindow * >(argp2);
51496 if (obj2) {
51497 ecode3 = SWIG_AsVal_int(obj2, &val3);
51498 if (!SWIG_IsOK(ecode3)) {
51499 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51500 }
51501 arg3 = static_cast< int >(val3);
51502 }
51503 {
51504 PyThreadState* __tstate = wxPyBeginAllowThreads();
51505 (arg1)->Above(arg2,arg3);
51506 wxPyEndAllowThreads(__tstate);
51507 if (PyErr_Occurred()) SWIG_fail;
51508 }
51509 resultobj = SWIG_Py_Void();
51510 return resultobj;
51511 fail:
51512 return NULL;
51513 }
51514
51515
51516 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51517 PyObject *resultobj = 0;
51518 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51519 wxWindow *arg2 = (wxWindow *) 0 ;
51520 int arg3 = (int) 0 ;
51521 void *argp1 = 0 ;
51522 int res1 = 0 ;
51523 void *argp2 = 0 ;
51524 int res2 = 0 ;
51525 int val3 ;
51526 int ecode3 = 0 ;
51527 PyObject * obj0 = 0 ;
51528 PyObject * obj1 = 0 ;
51529 PyObject * obj2 = 0 ;
51530 char * kwnames[] = {
51531 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51532 };
51533
51534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51536 if (!SWIG_IsOK(res1)) {
51537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51538 }
51539 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51540 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51541 if (!SWIG_IsOK(res2)) {
51542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51543 }
51544 arg2 = reinterpret_cast< wxWindow * >(argp2);
51545 if (obj2) {
51546 ecode3 = SWIG_AsVal_int(obj2, &val3);
51547 if (!SWIG_IsOK(ecode3)) {
51548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51549 }
51550 arg3 = static_cast< int >(val3);
51551 }
51552 {
51553 PyThreadState* __tstate = wxPyBeginAllowThreads();
51554 (arg1)->Below(arg2,arg3);
51555 wxPyEndAllowThreads(__tstate);
51556 if (PyErr_Occurred()) SWIG_fail;
51557 }
51558 resultobj = SWIG_Py_Void();
51559 return resultobj;
51560 fail:
51561 return NULL;
51562 }
51563
51564
51565 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51566 PyObject *resultobj = 0;
51567 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51568 wxWindow *arg2 = (wxWindow *) 0 ;
51569 wxEdge arg3 ;
51570 int arg4 = (int) 0 ;
51571 void *argp1 = 0 ;
51572 int res1 = 0 ;
51573 void *argp2 = 0 ;
51574 int res2 = 0 ;
51575 int val3 ;
51576 int ecode3 = 0 ;
51577 int val4 ;
51578 int ecode4 = 0 ;
51579 PyObject * obj0 = 0 ;
51580 PyObject * obj1 = 0 ;
51581 PyObject * obj2 = 0 ;
51582 PyObject * obj3 = 0 ;
51583 char * kwnames[] = {
51584 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51585 };
51586
51587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51589 if (!SWIG_IsOK(res1)) {
51590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51591 }
51592 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51593 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51594 if (!SWIG_IsOK(res2)) {
51595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51596 }
51597 arg2 = reinterpret_cast< wxWindow * >(argp2);
51598 ecode3 = SWIG_AsVal_int(obj2, &val3);
51599 if (!SWIG_IsOK(ecode3)) {
51600 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51601 }
51602 arg3 = static_cast< wxEdge >(val3);
51603 if (obj3) {
51604 ecode4 = SWIG_AsVal_int(obj3, &val4);
51605 if (!SWIG_IsOK(ecode4)) {
51606 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51607 }
51608 arg4 = static_cast< int >(val4);
51609 }
51610 {
51611 PyThreadState* __tstate = wxPyBeginAllowThreads();
51612 (arg1)->SameAs(arg2,arg3,arg4);
51613 wxPyEndAllowThreads(__tstate);
51614 if (PyErr_Occurred()) SWIG_fail;
51615 }
51616 resultobj = SWIG_Py_Void();
51617 return resultobj;
51618 fail:
51619 return NULL;
51620 }
51621
51622
51623 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51624 PyObject *resultobj = 0;
51625 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51626 wxWindow *arg2 = (wxWindow *) 0 ;
51627 wxEdge arg3 ;
51628 int arg4 ;
51629 void *argp1 = 0 ;
51630 int res1 = 0 ;
51631 void *argp2 = 0 ;
51632 int res2 = 0 ;
51633 int val3 ;
51634 int ecode3 = 0 ;
51635 int val4 ;
51636 int ecode4 = 0 ;
51637 PyObject * obj0 = 0 ;
51638 PyObject * obj1 = 0 ;
51639 PyObject * obj2 = 0 ;
51640 PyObject * obj3 = 0 ;
51641 char * kwnames[] = {
51642 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51643 };
51644
51645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51647 if (!SWIG_IsOK(res1)) {
51648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51649 }
51650 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51651 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51652 if (!SWIG_IsOK(res2)) {
51653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51654 }
51655 arg2 = reinterpret_cast< wxWindow * >(argp2);
51656 ecode3 = SWIG_AsVal_int(obj2, &val3);
51657 if (!SWIG_IsOK(ecode3)) {
51658 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51659 }
51660 arg3 = static_cast< wxEdge >(val3);
51661 ecode4 = SWIG_AsVal_int(obj3, &val4);
51662 if (!SWIG_IsOK(ecode4)) {
51663 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51664 }
51665 arg4 = static_cast< int >(val4);
51666 {
51667 PyThreadState* __tstate = wxPyBeginAllowThreads();
51668 (arg1)->PercentOf(arg2,arg3,arg4);
51669 wxPyEndAllowThreads(__tstate);
51670 if (PyErr_Occurred()) SWIG_fail;
51671 }
51672 resultobj = SWIG_Py_Void();
51673 return resultobj;
51674 fail:
51675 return NULL;
51676 }
51677
51678
51679 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51680 PyObject *resultobj = 0;
51681 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51682 int arg2 ;
51683 void *argp1 = 0 ;
51684 int res1 = 0 ;
51685 int val2 ;
51686 int ecode2 = 0 ;
51687 PyObject * obj0 = 0 ;
51688 PyObject * obj1 = 0 ;
51689 char * kwnames[] = {
51690 (char *) "self",(char *) "val", NULL
51691 };
51692
51693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51695 if (!SWIG_IsOK(res1)) {
51696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51697 }
51698 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51699 ecode2 = SWIG_AsVal_int(obj1, &val2);
51700 if (!SWIG_IsOK(ecode2)) {
51701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51702 }
51703 arg2 = static_cast< int >(val2);
51704 {
51705 PyThreadState* __tstate = wxPyBeginAllowThreads();
51706 (arg1)->Absolute(arg2);
51707 wxPyEndAllowThreads(__tstate);
51708 if (PyErr_Occurred()) SWIG_fail;
51709 }
51710 resultobj = SWIG_Py_Void();
51711 return resultobj;
51712 fail:
51713 return NULL;
51714 }
51715
51716
51717 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51718 PyObject *resultobj = 0;
51719 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51720 void *argp1 = 0 ;
51721 int res1 = 0 ;
51722 PyObject *swig_obj[1] ;
51723
51724 if (!args) SWIG_fail;
51725 swig_obj[0] = args;
51726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51727 if (!SWIG_IsOK(res1)) {
51728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51729 }
51730 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51731 {
51732 PyThreadState* __tstate = wxPyBeginAllowThreads();
51733 (arg1)->Unconstrained();
51734 wxPyEndAllowThreads(__tstate);
51735 if (PyErr_Occurred()) SWIG_fail;
51736 }
51737 resultobj = SWIG_Py_Void();
51738 return resultobj;
51739 fail:
51740 return NULL;
51741 }
51742
51743
51744 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51745 PyObject *resultobj = 0;
51746 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51747 void *argp1 = 0 ;
51748 int res1 = 0 ;
51749 PyObject *swig_obj[1] ;
51750
51751 if (!args) SWIG_fail;
51752 swig_obj[0] = args;
51753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51754 if (!SWIG_IsOK(res1)) {
51755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51756 }
51757 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51758 {
51759 PyThreadState* __tstate = wxPyBeginAllowThreads();
51760 (arg1)->AsIs();
51761 wxPyEndAllowThreads(__tstate);
51762 if (PyErr_Occurred()) SWIG_fail;
51763 }
51764 resultobj = SWIG_Py_Void();
51765 return resultobj;
51766 fail:
51767 return NULL;
51768 }
51769
51770
51771 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51772 PyObject *resultobj = 0;
51773 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51774 wxWindow *result = 0 ;
51775 void *argp1 = 0 ;
51776 int res1 = 0 ;
51777 PyObject *swig_obj[1] ;
51778
51779 if (!args) SWIG_fail;
51780 swig_obj[0] = args;
51781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51782 if (!SWIG_IsOK(res1)) {
51783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51784 }
51785 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51786 {
51787 PyThreadState* __tstate = wxPyBeginAllowThreads();
51788 result = (wxWindow *)(arg1)->GetOtherWindow();
51789 wxPyEndAllowThreads(__tstate);
51790 if (PyErr_Occurred()) SWIG_fail;
51791 }
51792 {
51793 resultobj = wxPyMake_wxObject(result, 0);
51794 }
51795 return resultobj;
51796 fail:
51797 return NULL;
51798 }
51799
51800
51801 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51802 PyObject *resultobj = 0;
51803 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51804 wxEdge result;
51805 void *argp1 = 0 ;
51806 int res1 = 0 ;
51807 PyObject *swig_obj[1] ;
51808
51809 if (!args) SWIG_fail;
51810 swig_obj[0] = args;
51811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51812 if (!SWIG_IsOK(res1)) {
51813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51814 }
51815 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51816 {
51817 PyThreadState* __tstate = wxPyBeginAllowThreads();
51818 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51819 wxPyEndAllowThreads(__tstate);
51820 if (PyErr_Occurred()) SWIG_fail;
51821 }
51822 resultobj = SWIG_From_int(static_cast< int >(result));
51823 return resultobj;
51824 fail:
51825 return NULL;
51826 }
51827
51828
51829 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51830 PyObject *resultobj = 0;
51831 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51832 wxEdge arg2 ;
51833 void *argp1 = 0 ;
51834 int res1 = 0 ;
51835 int val2 ;
51836 int ecode2 = 0 ;
51837 PyObject * obj0 = 0 ;
51838 PyObject * obj1 = 0 ;
51839 char * kwnames[] = {
51840 (char *) "self",(char *) "which", NULL
51841 };
51842
51843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51845 if (!SWIG_IsOK(res1)) {
51846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51847 }
51848 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51849 ecode2 = SWIG_AsVal_int(obj1, &val2);
51850 if (!SWIG_IsOK(ecode2)) {
51851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51852 }
51853 arg2 = static_cast< wxEdge >(val2);
51854 {
51855 PyThreadState* __tstate = wxPyBeginAllowThreads();
51856 (arg1)->SetEdge(arg2);
51857 wxPyEndAllowThreads(__tstate);
51858 if (PyErr_Occurred()) SWIG_fail;
51859 }
51860 resultobj = SWIG_Py_Void();
51861 return resultobj;
51862 fail:
51863 return NULL;
51864 }
51865
51866
51867 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51868 PyObject *resultobj = 0;
51869 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51870 int arg2 ;
51871 void *argp1 = 0 ;
51872 int res1 = 0 ;
51873 int val2 ;
51874 int ecode2 = 0 ;
51875 PyObject * obj0 = 0 ;
51876 PyObject * obj1 = 0 ;
51877 char * kwnames[] = {
51878 (char *) "self",(char *) "v", NULL
51879 };
51880
51881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51883 if (!SWIG_IsOK(res1)) {
51884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51885 }
51886 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51887 ecode2 = SWIG_AsVal_int(obj1, &val2);
51888 if (!SWIG_IsOK(ecode2)) {
51889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51890 }
51891 arg2 = static_cast< int >(val2);
51892 {
51893 PyThreadState* __tstate = wxPyBeginAllowThreads();
51894 (arg1)->SetValue(arg2);
51895 wxPyEndAllowThreads(__tstate);
51896 if (PyErr_Occurred()) SWIG_fail;
51897 }
51898 resultobj = SWIG_Py_Void();
51899 return resultobj;
51900 fail:
51901 return NULL;
51902 }
51903
51904
51905 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51906 PyObject *resultobj = 0;
51907 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51908 int result;
51909 void *argp1 = 0 ;
51910 int res1 = 0 ;
51911 PyObject *swig_obj[1] ;
51912
51913 if (!args) SWIG_fail;
51914 swig_obj[0] = args;
51915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51916 if (!SWIG_IsOK(res1)) {
51917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51918 }
51919 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51920 {
51921 PyThreadState* __tstate = wxPyBeginAllowThreads();
51922 result = (int)(arg1)->GetMargin();
51923 wxPyEndAllowThreads(__tstate);
51924 if (PyErr_Occurred()) SWIG_fail;
51925 }
51926 resultobj = SWIG_From_int(static_cast< int >(result));
51927 return resultobj;
51928 fail:
51929 return NULL;
51930 }
51931
51932
51933 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51934 PyObject *resultobj = 0;
51935 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51936 int arg2 ;
51937 void *argp1 = 0 ;
51938 int res1 = 0 ;
51939 int val2 ;
51940 int ecode2 = 0 ;
51941 PyObject * obj0 = 0 ;
51942 PyObject * obj1 = 0 ;
51943 char * kwnames[] = {
51944 (char *) "self",(char *) "m", NULL
51945 };
51946
51947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51949 if (!SWIG_IsOK(res1)) {
51950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51951 }
51952 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51953 ecode2 = SWIG_AsVal_int(obj1, &val2);
51954 if (!SWIG_IsOK(ecode2)) {
51955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51956 }
51957 arg2 = static_cast< int >(val2);
51958 {
51959 PyThreadState* __tstate = wxPyBeginAllowThreads();
51960 (arg1)->SetMargin(arg2);
51961 wxPyEndAllowThreads(__tstate);
51962 if (PyErr_Occurred()) SWIG_fail;
51963 }
51964 resultobj = SWIG_Py_Void();
51965 return resultobj;
51966 fail:
51967 return NULL;
51968 }
51969
51970
51971 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51972 PyObject *resultobj = 0;
51973 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51974 int result;
51975 void *argp1 = 0 ;
51976 int res1 = 0 ;
51977 PyObject *swig_obj[1] ;
51978
51979 if (!args) SWIG_fail;
51980 swig_obj[0] = args;
51981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51982 if (!SWIG_IsOK(res1)) {
51983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51984 }
51985 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51986 {
51987 PyThreadState* __tstate = wxPyBeginAllowThreads();
51988 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51989 wxPyEndAllowThreads(__tstate);
51990 if (PyErr_Occurred()) SWIG_fail;
51991 }
51992 resultobj = SWIG_From_int(static_cast< int >(result));
51993 return resultobj;
51994 fail:
51995 return NULL;
51996 }
51997
51998
51999 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52000 PyObject *resultobj = 0;
52001 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52002 int result;
52003 void *argp1 = 0 ;
52004 int res1 = 0 ;
52005 PyObject *swig_obj[1] ;
52006
52007 if (!args) SWIG_fail;
52008 swig_obj[0] = args;
52009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52010 if (!SWIG_IsOK(res1)) {
52011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52012 }
52013 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52014 {
52015 PyThreadState* __tstate = wxPyBeginAllowThreads();
52016 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52017 wxPyEndAllowThreads(__tstate);
52018 if (PyErr_Occurred()) SWIG_fail;
52019 }
52020 resultobj = SWIG_From_int(static_cast< int >(result));
52021 return resultobj;
52022 fail:
52023 return NULL;
52024 }
52025
52026
52027 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52028 PyObject *resultobj = 0;
52029 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52030 int result;
52031 void *argp1 = 0 ;
52032 int res1 = 0 ;
52033 PyObject *swig_obj[1] ;
52034
52035 if (!args) SWIG_fail;
52036 swig_obj[0] = args;
52037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52038 if (!SWIG_IsOK(res1)) {
52039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52040 }
52041 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52042 {
52043 PyThreadState* __tstate = wxPyBeginAllowThreads();
52044 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52045 wxPyEndAllowThreads(__tstate);
52046 if (PyErr_Occurred()) SWIG_fail;
52047 }
52048 resultobj = SWIG_From_int(static_cast< int >(result));
52049 return resultobj;
52050 fail:
52051 return NULL;
52052 }
52053
52054
52055 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52056 PyObject *resultobj = 0;
52057 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52058 bool result;
52059 void *argp1 = 0 ;
52060 int res1 = 0 ;
52061 PyObject *swig_obj[1] ;
52062
52063 if (!args) SWIG_fail;
52064 swig_obj[0] = args;
52065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52066 if (!SWIG_IsOK(res1)) {
52067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52068 }
52069 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52070 {
52071 PyThreadState* __tstate = wxPyBeginAllowThreads();
52072 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52073 wxPyEndAllowThreads(__tstate);
52074 if (PyErr_Occurred()) SWIG_fail;
52075 }
52076 {
52077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52078 }
52079 return resultobj;
52080 fail:
52081 return NULL;
52082 }
52083
52084
52085 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52086 PyObject *resultobj = 0;
52087 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52088 bool arg2 ;
52089 void *argp1 = 0 ;
52090 int res1 = 0 ;
52091 bool val2 ;
52092 int ecode2 = 0 ;
52093 PyObject * obj0 = 0 ;
52094 PyObject * obj1 = 0 ;
52095 char * kwnames[] = {
52096 (char *) "self",(char *) "d", NULL
52097 };
52098
52099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52101 if (!SWIG_IsOK(res1)) {
52102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52103 }
52104 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52105 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52106 if (!SWIG_IsOK(ecode2)) {
52107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52108 }
52109 arg2 = static_cast< bool >(val2);
52110 {
52111 PyThreadState* __tstate = wxPyBeginAllowThreads();
52112 (arg1)->SetDone(arg2);
52113 wxPyEndAllowThreads(__tstate);
52114 if (PyErr_Occurred()) SWIG_fail;
52115 }
52116 resultobj = SWIG_Py_Void();
52117 return resultobj;
52118 fail:
52119 return NULL;
52120 }
52121
52122
52123 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52124 PyObject *resultobj = 0;
52125 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52126 wxRelationship result;
52127 void *argp1 = 0 ;
52128 int res1 = 0 ;
52129 PyObject *swig_obj[1] ;
52130
52131 if (!args) SWIG_fail;
52132 swig_obj[0] = args;
52133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52134 if (!SWIG_IsOK(res1)) {
52135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52136 }
52137 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52138 {
52139 PyThreadState* __tstate = wxPyBeginAllowThreads();
52140 result = (wxRelationship)(arg1)->GetRelationship();
52141 wxPyEndAllowThreads(__tstate);
52142 if (PyErr_Occurred()) SWIG_fail;
52143 }
52144 resultobj = SWIG_From_int(static_cast< int >(result));
52145 return resultobj;
52146 fail:
52147 return NULL;
52148 }
52149
52150
52151 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52152 PyObject *resultobj = 0;
52153 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52154 wxRelationship arg2 ;
52155 void *argp1 = 0 ;
52156 int res1 = 0 ;
52157 int val2 ;
52158 int ecode2 = 0 ;
52159 PyObject * obj0 = 0 ;
52160 PyObject * obj1 = 0 ;
52161 char * kwnames[] = {
52162 (char *) "self",(char *) "r", NULL
52163 };
52164
52165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52167 if (!SWIG_IsOK(res1)) {
52168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52169 }
52170 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52171 ecode2 = SWIG_AsVal_int(obj1, &val2);
52172 if (!SWIG_IsOK(ecode2)) {
52173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52174 }
52175 arg2 = static_cast< wxRelationship >(val2);
52176 {
52177 PyThreadState* __tstate = wxPyBeginAllowThreads();
52178 (arg1)->SetRelationship(arg2);
52179 wxPyEndAllowThreads(__tstate);
52180 if (PyErr_Occurred()) SWIG_fail;
52181 }
52182 resultobj = SWIG_Py_Void();
52183 return resultobj;
52184 fail:
52185 return NULL;
52186 }
52187
52188
52189 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52190 PyObject *resultobj = 0;
52191 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52192 wxWindow *arg2 = (wxWindow *) 0 ;
52193 bool result;
52194 void *argp1 = 0 ;
52195 int res1 = 0 ;
52196 void *argp2 = 0 ;
52197 int res2 = 0 ;
52198 PyObject * obj0 = 0 ;
52199 PyObject * obj1 = 0 ;
52200 char * kwnames[] = {
52201 (char *) "self",(char *) "otherW", NULL
52202 };
52203
52204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52206 if (!SWIG_IsOK(res1)) {
52207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52208 }
52209 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52210 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52211 if (!SWIG_IsOK(res2)) {
52212 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52213 }
52214 arg2 = reinterpret_cast< wxWindow * >(argp2);
52215 {
52216 PyThreadState* __tstate = wxPyBeginAllowThreads();
52217 result = (bool)(arg1)->ResetIfWin(arg2);
52218 wxPyEndAllowThreads(__tstate);
52219 if (PyErr_Occurred()) SWIG_fail;
52220 }
52221 {
52222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52223 }
52224 return resultobj;
52225 fail:
52226 return NULL;
52227 }
52228
52229
52230 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52231 PyObject *resultobj = 0;
52232 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52233 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52234 wxWindow *arg3 = (wxWindow *) 0 ;
52235 bool result;
52236 void *argp1 = 0 ;
52237 int res1 = 0 ;
52238 void *argp2 = 0 ;
52239 int res2 = 0 ;
52240 void *argp3 = 0 ;
52241 int res3 = 0 ;
52242 PyObject * obj0 = 0 ;
52243 PyObject * obj1 = 0 ;
52244 PyObject * obj2 = 0 ;
52245 char * kwnames[] = {
52246 (char *) "self",(char *) "constraints",(char *) "win", NULL
52247 };
52248
52249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52251 if (!SWIG_IsOK(res1)) {
52252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52253 }
52254 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52255 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52256 if (!SWIG_IsOK(res2)) {
52257 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52258 }
52259 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52260 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52261 if (!SWIG_IsOK(res3)) {
52262 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52263 }
52264 arg3 = reinterpret_cast< wxWindow * >(argp3);
52265 {
52266 PyThreadState* __tstate = wxPyBeginAllowThreads();
52267 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52268 wxPyEndAllowThreads(__tstate);
52269 if (PyErr_Occurred()) SWIG_fail;
52270 }
52271 {
52272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52273 }
52274 return resultobj;
52275 fail:
52276 return NULL;
52277 }
52278
52279
52280 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52281 PyObject *resultobj = 0;
52282 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52283 wxEdge arg2 ;
52284 wxWindow *arg3 = (wxWindow *) 0 ;
52285 wxWindow *arg4 = (wxWindow *) 0 ;
52286 int result;
52287 void *argp1 = 0 ;
52288 int res1 = 0 ;
52289 int val2 ;
52290 int ecode2 = 0 ;
52291 void *argp3 = 0 ;
52292 int res3 = 0 ;
52293 void *argp4 = 0 ;
52294 int res4 = 0 ;
52295 PyObject * obj0 = 0 ;
52296 PyObject * obj1 = 0 ;
52297 PyObject * obj2 = 0 ;
52298 PyObject * obj3 = 0 ;
52299 char * kwnames[] = {
52300 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52301 };
52302
52303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52305 if (!SWIG_IsOK(res1)) {
52306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52307 }
52308 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52309 ecode2 = SWIG_AsVal_int(obj1, &val2);
52310 if (!SWIG_IsOK(ecode2)) {
52311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52312 }
52313 arg2 = static_cast< wxEdge >(val2);
52314 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52315 if (!SWIG_IsOK(res3)) {
52316 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52317 }
52318 arg3 = reinterpret_cast< wxWindow * >(argp3);
52319 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52320 if (!SWIG_IsOK(res4)) {
52321 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52322 }
52323 arg4 = reinterpret_cast< wxWindow * >(argp4);
52324 {
52325 PyThreadState* __tstate = wxPyBeginAllowThreads();
52326 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52327 wxPyEndAllowThreads(__tstate);
52328 if (PyErr_Occurred()) SWIG_fail;
52329 }
52330 resultobj = SWIG_From_int(static_cast< int >(result));
52331 return resultobj;
52332 fail:
52333 return NULL;
52334 }
52335
52336
52337 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52338 PyObject *obj;
52339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52340 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52341 return SWIG_Py_Void();
52342 }
52343
52344 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52345 PyObject *resultobj = 0;
52346 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52347 wxIndividualLayoutConstraint *result = 0 ;
52348 void *argp1 = 0 ;
52349 int res1 = 0 ;
52350 PyObject *swig_obj[1] ;
52351
52352 if (!args) SWIG_fail;
52353 swig_obj[0] = args;
52354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52355 if (!SWIG_IsOK(res1)) {
52356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52357 }
52358 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52359 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52361 return resultobj;
52362 fail:
52363 return NULL;
52364 }
52365
52366
52367 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52368 PyObject *resultobj = 0;
52369 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52370 wxIndividualLayoutConstraint *result = 0 ;
52371 void *argp1 = 0 ;
52372 int res1 = 0 ;
52373 PyObject *swig_obj[1] ;
52374
52375 if (!args) SWIG_fail;
52376 swig_obj[0] = args;
52377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52378 if (!SWIG_IsOK(res1)) {
52379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52380 }
52381 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52382 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52384 return resultobj;
52385 fail:
52386 return NULL;
52387 }
52388
52389
52390 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52391 PyObject *resultobj = 0;
52392 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52393 wxIndividualLayoutConstraint *result = 0 ;
52394 void *argp1 = 0 ;
52395 int res1 = 0 ;
52396 PyObject *swig_obj[1] ;
52397
52398 if (!args) SWIG_fail;
52399 swig_obj[0] = args;
52400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52401 if (!SWIG_IsOK(res1)) {
52402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52403 }
52404 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52405 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52407 return resultobj;
52408 fail:
52409 return NULL;
52410 }
52411
52412
52413 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52414 PyObject *resultobj = 0;
52415 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52416 wxIndividualLayoutConstraint *result = 0 ;
52417 void *argp1 = 0 ;
52418 int res1 = 0 ;
52419 PyObject *swig_obj[1] ;
52420
52421 if (!args) SWIG_fail;
52422 swig_obj[0] = args;
52423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52424 if (!SWIG_IsOK(res1)) {
52425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52426 }
52427 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52428 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52430 return resultobj;
52431 fail:
52432 return NULL;
52433 }
52434
52435
52436 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52437 PyObject *resultobj = 0;
52438 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52439 wxIndividualLayoutConstraint *result = 0 ;
52440 void *argp1 = 0 ;
52441 int res1 = 0 ;
52442 PyObject *swig_obj[1] ;
52443
52444 if (!args) SWIG_fail;
52445 swig_obj[0] = args;
52446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52447 if (!SWIG_IsOK(res1)) {
52448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52449 }
52450 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52451 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52453 return resultobj;
52454 fail:
52455 return NULL;
52456 }
52457
52458
52459 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52460 PyObject *resultobj = 0;
52461 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52462 wxIndividualLayoutConstraint *result = 0 ;
52463 void *argp1 = 0 ;
52464 int res1 = 0 ;
52465 PyObject *swig_obj[1] ;
52466
52467 if (!args) SWIG_fail;
52468 swig_obj[0] = args;
52469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52470 if (!SWIG_IsOK(res1)) {
52471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52472 }
52473 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52474 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52475 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52476 return resultobj;
52477 fail:
52478 return NULL;
52479 }
52480
52481
52482 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52483 PyObject *resultobj = 0;
52484 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52485 wxIndividualLayoutConstraint *result = 0 ;
52486 void *argp1 = 0 ;
52487 int res1 = 0 ;
52488 PyObject *swig_obj[1] ;
52489
52490 if (!args) SWIG_fail;
52491 swig_obj[0] = args;
52492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52493 if (!SWIG_IsOK(res1)) {
52494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52495 }
52496 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52497 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52499 return resultobj;
52500 fail:
52501 return NULL;
52502 }
52503
52504
52505 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52506 PyObject *resultobj = 0;
52507 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52508 wxIndividualLayoutConstraint *result = 0 ;
52509 void *argp1 = 0 ;
52510 int res1 = 0 ;
52511 PyObject *swig_obj[1] ;
52512
52513 if (!args) SWIG_fail;
52514 swig_obj[0] = args;
52515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52516 if (!SWIG_IsOK(res1)) {
52517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52518 }
52519 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52520 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52522 return resultobj;
52523 fail:
52524 return NULL;
52525 }
52526
52527
52528 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52529 PyObject *resultobj = 0;
52530 wxLayoutConstraints *result = 0 ;
52531
52532 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52533 {
52534 PyThreadState* __tstate = wxPyBeginAllowThreads();
52535 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52536 wxPyEndAllowThreads(__tstate);
52537 if (PyErr_Occurred()) SWIG_fail;
52538 }
52539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52540 return resultobj;
52541 fail:
52542 return NULL;
52543 }
52544
52545
52546 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52547 PyObject *resultobj = 0;
52548 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52549 void *argp1 = 0 ;
52550 int res1 = 0 ;
52551 PyObject *swig_obj[1] ;
52552
52553 if (!args) SWIG_fail;
52554 swig_obj[0] = args;
52555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52556 if (!SWIG_IsOK(res1)) {
52557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52558 }
52559 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52560 {
52561 PyThreadState* __tstate = wxPyBeginAllowThreads();
52562 delete arg1;
52563
52564 wxPyEndAllowThreads(__tstate);
52565 if (PyErr_Occurred()) SWIG_fail;
52566 }
52567 resultobj = SWIG_Py_Void();
52568 return resultobj;
52569 fail:
52570 return NULL;
52571 }
52572
52573
52574 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52575 PyObject *resultobj = 0;
52576 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52577 wxWindow *arg2 = (wxWindow *) 0 ;
52578 int *arg3 = (int *) 0 ;
52579 bool result;
52580 void *argp1 = 0 ;
52581 int res1 = 0 ;
52582 void *argp2 = 0 ;
52583 int res2 = 0 ;
52584 int temp3 ;
52585 int res3 = SWIG_TMPOBJ ;
52586 PyObject * obj0 = 0 ;
52587 PyObject * obj1 = 0 ;
52588 char * kwnames[] = {
52589 (char *) "self",(char *) "win", NULL
52590 };
52591
52592 arg3 = &temp3;
52593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52595 if (!SWIG_IsOK(res1)) {
52596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52597 }
52598 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52599 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52600 if (!SWIG_IsOK(res2)) {
52601 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52602 }
52603 arg2 = reinterpret_cast< wxWindow * >(argp2);
52604 {
52605 PyThreadState* __tstate = wxPyBeginAllowThreads();
52606 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52607 wxPyEndAllowThreads(__tstate);
52608 if (PyErr_Occurred()) SWIG_fail;
52609 }
52610 {
52611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52612 }
52613 if (SWIG_IsTmpObj(res3)) {
52614 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52615 } else {
52616 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52618 }
52619 return resultobj;
52620 fail:
52621 return NULL;
52622 }
52623
52624
52625 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52626 PyObject *resultobj = 0;
52627 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52628 bool result;
52629 void *argp1 = 0 ;
52630 int res1 = 0 ;
52631 PyObject *swig_obj[1] ;
52632
52633 if (!args) SWIG_fail;
52634 swig_obj[0] = args;
52635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52636 if (!SWIG_IsOK(res1)) {
52637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52638 }
52639 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52640 {
52641 PyThreadState* __tstate = wxPyBeginAllowThreads();
52642 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52643 wxPyEndAllowThreads(__tstate);
52644 if (PyErr_Occurred()) SWIG_fail;
52645 }
52646 {
52647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52648 }
52649 return resultobj;
52650 fail:
52651 return NULL;
52652 }
52653
52654
52655 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52656 PyObject *obj;
52657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52658 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52659 return SWIG_Py_Void();
52660 }
52661
52662 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52663 return SWIG_Python_InitShadowInstance(args);
52664 }
52665
52666 static PyMethodDef SwigMethods[] = {
52667 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52668 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52669 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52670 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52671 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52672 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52673 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52674 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52675 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52676 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52677 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52678 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52679 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52680 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52681 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52682 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52683 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52684 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52685 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52686 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52687 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52688 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52689 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52690 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52691 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52692 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52693 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52694 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52695 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52696 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52697 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52698 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52699 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52700 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52701 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52702 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52703 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52704 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52705 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52706 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52707 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52708 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52709 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52710 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52711 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52712 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52713 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52714 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52715 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52716 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52717 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52718 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52719 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52720 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52721 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52722 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52723 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52724 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52725 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52726 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52727 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52728 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52729 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52730 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52731 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52732 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52733 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52734 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52735 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52736 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52737 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52738 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52739 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52740 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52741 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52742 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52743 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52744 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52745 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52746 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52747 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52748 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52749 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52750 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52751 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52752 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52753 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52754 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52755 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52756 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52757 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52758 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52759 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52760 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52761 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52762 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52763 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52764 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52765 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52766 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52767 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52768 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52769 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52770 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52771 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52772 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52773 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52774 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52775 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52776 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52777 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52778 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52779 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52780 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52781 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52782 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52783 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52784 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52785 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52786 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52787 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52788 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52789 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52790 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52791 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52792 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52793 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52794 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52795 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52796 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52797 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52798 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52799 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52800 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52801 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52802 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52803 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52804 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52805 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52806 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52807 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52808 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52809 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52810 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52811 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52812 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52813 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52814 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52815 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52816 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52818 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52819 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52820 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52821 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52822 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52823 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52824 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52825 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52826 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52827 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52828 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52829 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52830 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52831 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52832 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52833 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52834 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52835 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52836 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52837 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52838 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52839 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52840 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52841 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52842 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52843 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52844 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52845 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52846 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52847 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52848 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52849 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52850 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52851 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52852 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52853 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52854 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52855 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52856 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52857 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52858 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52859 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52860 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52861 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52862 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52863 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52864 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52865 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52866 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52867 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52868 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52869 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52870 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52871 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52872 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52873 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52874 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52875 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52876 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52877 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52878 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52879 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52880 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52882 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52883 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52884 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52885 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52886 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52887 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52888 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52889 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52890 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52891 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52892 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52893 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52894 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52895 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52896 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52897 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52898 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52899 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52900 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52901 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52902 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52903 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52904 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52905 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52906 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52907 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52908 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52909 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52910 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52911 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52912 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52913 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52914 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52915 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52916 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52917 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52918 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52919 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52920 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52921 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52922 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52923 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52924 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52925 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52926 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52927 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52928 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52929 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52930 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52931 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52932 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52933 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52934 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52935 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52936 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52937 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52938 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52940 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52941 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52942 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52943 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52944 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52945 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52946 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52947 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52948 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52949 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52950 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52951 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52952 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52953 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52954 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52955 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52956 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52957 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52958 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52959 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52960 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52961 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52962 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52963 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52964 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52965 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52966 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52967 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52968 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52969 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52970 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52971 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52972 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52973 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52974 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52975 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52976 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52977 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52978 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52979 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52980 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52981 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52982 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52983 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52984 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52985 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52986 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52987 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52988 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52989 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52990 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52991 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52992 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52993 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52994 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52995 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52996 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52997 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52998 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52999 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53000 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53001 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53002 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53003 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53004 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53005 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53006 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53007 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53008 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53009 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53010 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53011 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53012 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53013 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53014 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53015 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53016 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53017 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53018 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53019 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53020 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53021 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53022 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53023 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53024 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53025 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53026 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53027 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53028 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53029 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53030 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53031 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53032 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53033 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53034 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53035 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53036 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53037 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53038 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53039 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53040 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53041 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53042 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53043 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53044 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53045 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53046 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53047 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53048 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53049 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53050 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53051 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53052 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53053 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53054 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53055 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53056 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53058 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53061 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53062 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53063 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53064 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53065 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53066 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53067 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53068 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53069 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53070 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53071 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53072 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53074 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53075 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53076 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53077 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53078 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53079 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53080 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53081 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53082 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53083 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53084 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53085 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53087 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53088 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53089 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53090 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53091 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53092 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53093 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53095 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53096 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53097 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53098 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53099 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53101 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53103 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53104 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53105 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53106 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53107 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53108 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53109 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53110 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53111 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53112 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53113 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53114 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53115 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53116 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53117 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53120 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53121 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53123 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53124 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53125 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53126 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53127 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53128 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53129 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53130 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53133 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53136 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53137 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53138 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53139 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53140 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53141 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53142 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53143 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53144 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53145 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53146 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53147 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53148 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53149 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53150 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53151 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53152 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53153 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53154 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53155 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53156 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53157 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53158 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53159 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53161 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53162 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53163 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53164 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53165 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53166 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53167 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53168 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53169 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53170 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53171 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53172 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53173 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53174 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53175 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53176 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53177 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53178 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53179 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53180 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53181 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53182 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53183 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53184 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53185 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53186 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53187 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53188 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53189 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53190 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53191 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53192 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53193 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53194 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53195 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53196 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53197 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53198 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53199 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53200 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53201 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53202 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53203 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53204 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53205 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53206 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53207 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53208 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53209 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53210 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53211 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53212 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53213 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53214 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53215 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53216 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53217 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53218 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53219 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53220 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53221 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53222 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53223 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53224 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53225 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53226 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53227 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53228 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53229 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53230 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53231 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53232 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53233 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53234 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53235 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53236 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53237 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53238 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53239 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53240 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53241 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53242 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53243 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53244 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53245 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53246 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53247 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53248 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53249 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53250 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53252 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53253 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53254 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53255 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53256 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53257 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53258 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53259 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53260 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53261 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53262 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53263 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53264 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53265 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53266 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53267 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53268 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53269 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53270 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53271 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53272 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53273 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53274 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53275 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53276 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53277 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53278 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53279 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53280 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53281 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53282 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53283 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53284 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53285 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53286 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53287 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53288 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53289 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53290 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53291 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53292 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53293 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53294 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53295 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53296 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53297 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53298 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53299 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53300 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53301 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53302 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53303 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53304 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53305 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53306 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53307 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53308 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53309 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53310 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53311 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53312 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53313 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53314 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53315 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53316 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53317 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53318 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53319 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53320 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53321 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53322 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53323 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53324 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53325 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53329 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53331 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53333 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53334 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53335 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53336 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53337 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53338 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53339 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53340 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53341 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53342 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53343 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53344 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53345 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53348 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53349 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53350 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53353 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53354 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53355 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53356 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53357 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53359 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53361 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53362 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53363 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53364 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53365 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53366 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53367 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53368 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53369 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53370 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53371 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53373 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53374 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53375 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53376 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53377 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53379 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53380 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53381 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53383 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53385 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53387 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53388 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53389 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53390 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53391 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53392 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53393 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53395 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53396 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53397 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53398 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53399 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53400 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53401 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53402 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53403 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53404 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53405 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53406 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53407 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53408 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53409 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53410 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53412 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53414 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53415 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53416 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53417 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53418 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53419 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53421 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53422 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53423 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53424 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53425 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53426 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53427 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53428 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53430 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53431 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53432 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53433 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53434 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53435 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53436 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53437 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53438 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53439 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53440 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53441 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53442 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53443 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53444 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53445 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53446 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53448 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53449 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53451 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53452 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53453 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53454 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53455 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53456 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53457 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53458 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53459 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53461 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53462 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53464 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53465 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53466 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53467 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53468 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53469 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53470 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53471 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53472 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53474 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53475 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53476 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53477 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53478 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53479 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53481 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53483 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53484 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53485 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53486 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53487 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53489 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53490 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53491 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53492 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53494 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53495 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53496 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53497 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53498 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53499 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53500 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53501 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53502 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53503 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53505 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53506 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53508 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53509 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53510 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53512 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53513 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53514 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53515 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53516 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53518 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53519 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53524 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53526 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53527 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53529 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53530 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53531 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53532 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53534 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53535 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53536 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53537 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53538 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53539 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53540 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53541 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53542 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53543 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53544 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53545 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53546 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53547 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53548 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53550 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53551 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53552 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53553 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53554 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53555 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53556 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53557 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53558 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53560 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53561 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53562 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53564 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53565 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53566 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53567 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53568 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53570 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53571 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53572 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53574 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53575 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53576 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53577 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53578 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53579 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53580 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53581 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53582 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53583 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53584 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53587 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53588 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53589 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53590 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53591 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53592 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53593 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53594 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53595 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53599 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53600 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53601 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53602 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53608 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53609 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53610 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53615 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53616 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53617 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53618 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53619 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53620 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53621 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53622 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53623 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53626 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53627 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53631 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53632 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53633 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53634 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53635 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53636 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53637 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53638 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53639 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53640 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53642 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53643 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53644 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53647 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53648 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53649 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53652 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53653 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53654 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53655 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53656 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53657 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53658 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53659 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53661 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53662 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53664 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53666 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53667 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53668 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53674 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53675 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53677 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53681 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53683 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53684 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53693 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53694 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53695 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53696 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53697 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53699 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53700 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53701 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53703 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53704 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53705 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53708 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53710 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53711 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53714 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53716 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53717 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53718 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53719 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53720 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53725 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53726 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53727 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53729 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53730 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53731 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53733 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53735 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53736 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53737 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53739 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53740 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53743 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53751 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53754 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53755 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53758 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53766 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53769 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53770 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53780 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53783 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53785 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53787 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53788 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53790 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53792 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53793 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53795 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53796 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53797 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53801 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53817 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53819 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53820 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53821 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53823 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53825 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53826 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53827 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53829 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53830 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53831 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53833 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53834 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53836 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53837 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53839 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53842 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53843 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53845 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53847 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53849 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53850 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53852 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53853 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53856 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53858 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53860 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53862 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53865 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53867 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53868 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53869 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53871 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53872 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53873 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53875 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53878 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53880 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53881 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53882 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53885 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53889 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53890 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53891 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53892 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53895 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53896 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53898 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53900 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53901 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53902 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53903 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53904 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53907 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53908 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53909 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53910 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53912 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53913 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53915 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53918 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53919 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53920 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53921 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53922 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53924 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53925 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53926 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53928 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53929 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53930 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53931 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53933 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53934 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53936 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53937 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53938 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53940 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53941 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53942 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53956 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53957 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53958 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53959 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53960 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53961 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53964 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53965 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53967 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53968 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53972 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53973 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53975 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53976 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53978 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53980 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53981 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53983 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53984 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53985 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53987 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53988 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53989 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53990 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53991 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53992 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53993 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53994 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53995 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53996 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54003 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54005 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54006 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54007 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54008 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54009 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54010 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54012 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54013 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54016 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54017 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54018 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54019 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54020 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54021 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54022 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54024 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54025 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54026 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54029 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54032 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54033 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54034 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54035 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54036 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54037 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54038 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54042 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54043 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54044 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54045 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54046 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54047 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54048 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54051 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54052 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54053 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54055 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54058 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54059 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54060 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54061 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54062 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54065 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54067 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54068 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54069 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54070 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54071 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54072 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54073 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54075 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54077 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54078 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54079 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54080 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54081 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54086 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54087 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54088 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54089 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54090 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54091 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54094 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54095 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54096 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54097 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54098 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54099 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54100 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54101 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54104 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54106 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54107 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54108 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54109 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54110 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54111 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54112 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54113 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54114 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54115 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54116 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54117 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54118 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54119 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54120 { NULL, NULL, 0, NULL }
54121 };
54122
54123
54124 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54125
54126 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54127 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54128 }
54129 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54130 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54131 }
54132 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54133 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54134 }
54135 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54136 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54137 }
54138 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54139 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54140 }
54141 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54142 return (void *)((wxSizer *) ((wxGridSizer *) x));
54143 }
54144 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54145 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54146 }
54147 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54148 return (void *)((wxSizer *) ((wxPySizer *) x));
54149 }
54150 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54151 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54152 }
54153 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54154 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54155 }
54156 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54157 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54158 }
54159 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54160 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54161 }
54162 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54163 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54164 }
54165 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54166 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54167 }
54168 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54169 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54170 }
54171 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54172 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54173 }
54174 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54175 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54176 }
54177 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54178 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54179 }
54180 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54181 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54182 }
54183 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54184 return (void *)((wxEvent *) ((wxPyEvent *) x));
54185 }
54186 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54187 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54188 }
54189 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54190 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54191 }
54192 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54193 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54194 }
54195 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54196 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54197 }
54198 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54199 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54200 }
54201 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54202 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54203 }
54204 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54205 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54206 }
54207 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54208 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54209 }
54210 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54211 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54212 }
54213 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54214 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54215 }
54216 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54217 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54218 }
54219 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54220 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54221 }
54222 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54223 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54224 }
54225 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54226 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54227 }
54228 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54229 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54230 }
54231 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54232 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54233 }
54234 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54235 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54236 }
54237 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54238 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54239 }
54240 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54241 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54242 }
54243 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54244 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54245 }
54246 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54247 return (void *)((wxEvent *) ((wxShowEvent *) x));
54248 }
54249 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54250 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54251 }
54252 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54253 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54254 }
54255 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54256 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54257 }
54258 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54259 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54260 }
54261 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54262 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54263 }
54264 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54265 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54266 }
54267 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54268 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54269 }
54270 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54271 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54272 }
54273 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54274 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54275 }
54276 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54277 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54278 }
54279 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54280 return (void *)((wxControl *) ((wxControlWithItems *) x));
54281 }
54282 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54283 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54284 }
54285 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54286 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54287 }
54288 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54289 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54290 }
54291 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54292 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54293 }
54294 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54295 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54296 }
54297 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54298 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54299 }
54300 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54301 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54302 }
54303 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54304 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54305 }
54306 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54307 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54308 }
54309 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54310 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54311 }
54312 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54313 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54314 }
54315 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54316 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54317 }
54318 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54319 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54320 }
54321 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54322 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54323 }
54324 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54325 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54326 }
54327 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54328 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54329 }
54330 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54331 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54332 }
54333 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54334 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54335 }
54336 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54337 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54338 }
54339 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54340 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54341 }
54342 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54343 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54344 }
54345 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54346 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54347 }
54348 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54349 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54350 }
54351 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54352 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54353 }
54354 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54355 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54356 }
54357 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54358 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54359 }
54360 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54361 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54362 }
54363 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54364 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54365 }
54366 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54367 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54368 }
54369 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54370 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54371 }
54372 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54373 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54374 }
54375 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54376 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54377 }
54378 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54379 return (void *)((wxObject *) ((wxSizerItem *) x));
54380 }
54381 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54382 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54383 }
54384 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54385 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54386 }
54387 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54388 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54389 }
54390 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54391 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54392 }
54393 static void *_p_wxSizerTo_p_wxObject(void *x) {
54394 return (void *)((wxObject *) ((wxSizer *) x));
54395 }
54396 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54397 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54398 }
54399 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54400 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54401 }
54402 static void *_p_wxEventTo_p_wxObject(void *x) {
54403 return (void *)((wxObject *) ((wxEvent *) x));
54404 }
54405 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54406 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54407 }
54408 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54409 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54410 }
54411 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54412 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54413 }
54414 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54415 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54416 }
54417 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54418 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54419 }
54420 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54421 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54422 }
54423 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54424 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54425 }
54426 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54427 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54428 }
54429 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54430 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54431 }
54432 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54433 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54434 }
54435 static void *_p_wxControlTo_p_wxObject(void *x) {
54436 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54437 }
54438 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54439 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54440 }
54441 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54442 return (void *)((wxObject *) ((wxFSFile *) x));
54443 }
54444 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54445 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54446 }
54447 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54448 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54449 }
54450 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54451 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54452 }
54453 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54454 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54455 }
54456 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54457 return (void *)((wxObject *) ((wxMenuItem *) x));
54458 }
54459 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54460 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54461 }
54462 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54463 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54464 }
54465 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54466 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54467 }
54468 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54469 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54470 }
54471 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54472 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54473 }
54474 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54475 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54476 }
54477 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54478 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54479 }
54480 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54481 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54482 }
54483 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54484 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54485 }
54486 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54487 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54488 }
54489 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54490 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54491 }
54492 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54493 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54494 }
54495 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54496 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54497 }
54498 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54499 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54500 }
54501 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54502 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54503 }
54504 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54505 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54506 }
54507 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54508 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54509 }
54510 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54511 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54512 }
54513 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54514 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54515 }
54516 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54517 return (void *)((wxObject *) ((wxImageHandler *) x));
54518 }
54519 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54520 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54521 }
54522 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54523 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54524 }
54525 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54526 return (void *)((wxObject *) ((wxEvtHandler *) x));
54527 }
54528 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54529 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54530 }
54531 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54532 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54533 }
54534 static void *_p_wxImageTo_p_wxObject(void *x) {
54535 return (void *)((wxObject *) ((wxImage *) x));
54536 }
54537 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54538 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54539 }
54540 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54541 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54542 }
54543 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54544 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54545 }
54546 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54547 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54548 }
54549 static void *_p_wxWindowTo_p_wxObject(void *x) {
54550 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54551 }
54552 static void *_p_wxMenuTo_p_wxObject(void *x) {
54553 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54554 }
54555 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54556 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54557 }
54558 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54559 return (void *)((wxObject *) ((wxFileSystem *) x));
54560 }
54561 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54562 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54563 }
54564 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54565 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54566 }
54567 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54568 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54569 }
54570 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54571 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54572 }
54573 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54574 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54575 }
54576 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54577 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54578 }
54579 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54580 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54581 }
54582 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54583 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54584 }
54585 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54586 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54587 }
54588 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54589 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54590 }
54591 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54592 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54593 }
54594 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54595 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54596 }
54597 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54598 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54599 }
54600 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54601 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54602 }
54603 static void *_p_wxControlTo_p_wxWindow(void *x) {
54604 return (void *)((wxWindow *) ((wxControl *) x));
54605 }
54606 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54607 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54608 }
54609 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54610 return (void *)((wxWindow *) ((wxMenuBar *) x));
54611 }
54612 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54613 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54614 }
54615 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54616 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54617 }
54618 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54619 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54620 }
54621 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54622 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54623 }
54624 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54625 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54626 }
54627 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54628 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54629 }
54630 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54631 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54632 }
54633 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54634 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54635 }
54636 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54637 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54638 }
54639 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54640 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54641 }
54642 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54643 return (void *)((wxValidator *) ((wxPyValidator *) x));
54644 }
54645 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54646 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54647 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};
54648 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54649 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54650 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54651 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54652 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54653 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54654 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54655 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54656 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54657 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54658 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54659 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54660 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54661 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54662 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54663 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54664 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54665 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54666 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54667 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54668 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54669 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54670 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54671 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54672 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54673 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54674 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54675 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54676 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54677 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54678 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54679 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54680 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54681 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54682 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54683 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54684 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54685 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54686 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54687 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54688 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54689 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54690 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54691 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54692 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54693 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54694 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54695 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54696 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54697 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54698 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
54699 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54700 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54701 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54702 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54703 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54704 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54705 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54706 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54707 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54708 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54709 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54710 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54711 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54712 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54713 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54714 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54715 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54716 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54717 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54718 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54719 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54720 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54721 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54722 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54723 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54724 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54725 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54726 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54727 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54728 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54729 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54730 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54731 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54732 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54733 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54734 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54735 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54736 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54737 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54738 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54739 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54740 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54741 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54742 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54743 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54744 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54745 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54746 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54747 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54748 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54749 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54750 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54751 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54752 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54753 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54754 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54755 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54756 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54757 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54758 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54759 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54760 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54761 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54762 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54763 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54764 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54765 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54766 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54767 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54768 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54769 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54770 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54771 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54772 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54773 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54774 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54775 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54776
54777 static swig_type_info *swig_type_initial[] = {
54778 &_swigt__p_buffer,
54779 &_swigt__p_char,
54780 &_swigt__p_form_ops_t,
54781 &_swigt__p_int,
54782 &_swigt__p_long,
54783 &_swigt__p_unsigned_char,
54784 &_swigt__p_unsigned_int,
54785 &_swigt__p_unsigned_long,
54786 &_swigt__p_wxANIHandler,
54787 &_swigt__p_wxAcceleratorEntry,
54788 &_swigt__p_wxAcceleratorTable,
54789 &_swigt__p_wxActivateEvent,
54790 &_swigt__p_wxAppTraits,
54791 &_swigt__p_wxArrayString,
54792 &_swigt__p_wxBMPHandler,
54793 &_swigt__p_wxBitmap,
54794 &_swigt__p_wxBoxSizer,
54795 &_swigt__p_wxButton,
54796 &_swigt__p_wxCURHandler,
54797 &_swigt__p_wxCaret,
54798 &_swigt__p_wxChildFocusEvent,
54799 &_swigt__p_wxClipboardTextEvent,
54800 &_swigt__p_wxCloseEvent,
54801 &_swigt__p_wxColour,
54802 &_swigt__p_wxCommandEvent,
54803 &_swigt__p_wxContextMenuEvent,
54804 &_swigt__p_wxControl,
54805 &_swigt__p_wxControlWithItems,
54806 &_swigt__p_wxCursor,
54807 &_swigt__p_wxDC,
54808 &_swigt__p_wxDateEvent,
54809 &_swigt__p_wxDateTime,
54810 &_swigt__p_wxDisplayChangedEvent,
54811 &_swigt__p_wxDropFilesEvent,
54812 &_swigt__p_wxDuplexMode,
54813 &_swigt__p_wxEraseEvent,
54814 &_swigt__p_wxEvent,
54815 &_swigt__p_wxEventLoop,
54816 &_swigt__p_wxEventLoopActivator,
54817 &_swigt__p_wxEvtHandler,
54818 &_swigt__p_wxFSFile,
54819 &_swigt__p_wxFileSystem,
54820 &_swigt__p_wxFileSystemHandler,
54821 &_swigt__p_wxFlexGridSizer,
54822 &_swigt__p_wxFocusEvent,
54823 &_swigt__p_wxFont,
54824 &_swigt__p_wxFrame,
54825 &_swigt__p_wxGBPosition,
54826 &_swigt__p_wxGBSizerItem,
54827 &_swigt__p_wxGBSpan,
54828 &_swigt__p_wxGIFHandler,
54829 &_swigt__p_wxGridBagSizer,
54830 &_swigt__p_wxGridSizer,
54831 &_swigt__p_wxHelpEvent__Origin,
54832 &_swigt__p_wxICOHandler,
54833 &_swigt__p_wxIconizeEvent,
54834 &_swigt__p_wxIdleEvent,
54835 &_swigt__p_wxImage,
54836 &_swigt__p_wxImageHandler,
54837 &_swigt__p_wxImageHistogram,
54838 &_swigt__p_wxImage_HSVValue,
54839 &_swigt__p_wxImage_RGBValue,
54840 &_swigt__p_wxIndividualLayoutConstraint,
54841 &_swigt__p_wxInitDialogEvent,
54842 &_swigt__p_wxInputStream,
54843 &_swigt__p_wxInternetFSHandler,
54844 &_swigt__p_wxItemContainer,
54845 &_swigt__p_wxJPEGHandler,
54846 &_swigt__p_wxKeyEvent,
54847 &_swigt__p_wxLayoutConstraints,
54848 &_swigt__p_wxMaximizeEvent,
54849 &_swigt__p_wxMemoryFSHandler,
54850 &_swigt__p_wxMenu,
54851 &_swigt__p_wxMenuBar,
54852 &_swigt__p_wxMenuBarBase,
54853 &_swigt__p_wxMenuEvent,
54854 &_swigt__p_wxMenuItem,
54855 &_swigt__p_wxMouseCaptureChangedEvent,
54856 &_swigt__p_wxMouseEvent,
54857 &_swigt__p_wxMoveEvent,
54858 &_swigt__p_wxNavigationKeyEvent,
54859 &_swigt__p_wxNcPaintEvent,
54860 &_swigt__p_wxNotifyEvent,
54861 &_swigt__p_wxObject,
54862 &_swigt__p_wxOutputStream,
54863 &_swigt__p_wxPCXHandler,
54864 &_swigt__p_wxPNGHandler,
54865 &_swigt__p_wxPNMHandler,
54866 &_swigt__p_wxPaintEvent,
54867 &_swigt__p_wxPaletteChangedEvent,
54868 &_swigt__p_wxPaperSize,
54869 &_swigt__p_wxPoint,
54870 &_swigt__p_wxPoint2D,
54871 &_swigt__p_wxPropagateOnce,
54872 &_swigt__p_wxPropagationDisabler,
54873 &_swigt__p_wxPyApp,
54874 &_swigt__p_wxPyCommandEvent,
54875 &_swigt__p_wxPyDropTarget,
54876 &_swigt__p_wxPyEvent,
54877 &_swigt__p_wxPyFileSystemHandler,
54878 &_swigt__p_wxPyImageHandler,
54879 &_swigt__p_wxPyInputStream,
54880 &_swigt__p_wxPySizer,
54881 &_swigt__p_wxPyValidator,
54882 &_swigt__p_wxQuantize,
54883 &_swigt__p_wxQueryNewPaletteEvent,
54884 &_swigt__p_wxRealPoint,
54885 &_swigt__p_wxRect,
54886 &_swigt__p_wxRegion,
54887 &_swigt__p_wxScrollEvent,
54888 &_swigt__p_wxScrollWinEvent,
54889 &_swigt__p_wxSetCursorEvent,
54890 &_swigt__p_wxShowEvent,
54891 &_swigt__p_wxSize,
54892 &_swigt__p_wxSizeEvent,
54893 &_swigt__p_wxSizer,
54894 &_swigt__p_wxSizerItem,
54895 &_swigt__p_wxStaticBox,
54896 &_swigt__p_wxStaticBoxSizer,
54897 &_swigt__p_wxStdDialogButtonSizer,
54898 &_swigt__p_wxSysColourChangedEvent,
54899 &_swigt__p_wxTIFFHandler,
54900 &_swigt__p_wxToolTip,
54901 &_swigt__p_wxUpdateUIEvent,
54902 &_swigt__p_wxValidator,
54903 &_swigt__p_wxVisualAttributes,
54904 &_swigt__p_wxWindow,
54905 &_swigt__p_wxWindowCreateEvent,
54906 &_swigt__p_wxWindowDestroyEvent,
54907 &_swigt__p_wxXPMHandler,
54908 &_swigt__p_wxZipFSHandler,
54909 };
54910
54911 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54912 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54913 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54914 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54915 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54916 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54917 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54918 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54919 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54920 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54921 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54922 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54923 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54924 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54925 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}};
54926 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54927 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}};
54928 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54929 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}};
54930 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54931 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54932 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
54933 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54934 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54935 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}};
54936 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54937 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}};
54938 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54939 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54940 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54941 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54942 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54943 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54944 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54945 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54946 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54947 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_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
54948 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54949 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54950 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}};
54951 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54952 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54953 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}};
54954 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}};
54955 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54956 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54957 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54958 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54959 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54960 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54961 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54962 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54963 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}};
54964 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
54965 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}};
54966 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54967 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54968 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54969 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}};
54970 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54971 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54972 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54973 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54974 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54975 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54976 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54977 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}};
54978 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54979 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54980 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54981 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54982 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54983 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54984 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54985 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54986 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54987 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54988 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54989 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54990 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54991 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54992 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54993 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54994 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_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_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_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_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
54995 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54996 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54997 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54998 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54999 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55000 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55001 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55002 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55003 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55004 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55005 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55006 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55007 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55008 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55009 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55010 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55011 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55012 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55013 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55014 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55015 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55016 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55017 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55018 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55019 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55020 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55021 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55022 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55023 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55024 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55025 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55026 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}};
55027 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}};
55028 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55029 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55030 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55031 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55032 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55033 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55034 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55035 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}};
55036 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55037 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}};
55038 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55039 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55040 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55041 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55042
55043 static swig_cast_info *swig_cast_initial[] = {
55044 _swigc__p_buffer,
55045 _swigc__p_char,
55046 _swigc__p_form_ops_t,
55047 _swigc__p_int,
55048 _swigc__p_long,
55049 _swigc__p_unsigned_char,
55050 _swigc__p_unsigned_int,
55051 _swigc__p_unsigned_long,
55052 _swigc__p_wxANIHandler,
55053 _swigc__p_wxAcceleratorEntry,
55054 _swigc__p_wxAcceleratorTable,
55055 _swigc__p_wxActivateEvent,
55056 _swigc__p_wxAppTraits,
55057 _swigc__p_wxArrayString,
55058 _swigc__p_wxBMPHandler,
55059 _swigc__p_wxBitmap,
55060 _swigc__p_wxBoxSizer,
55061 _swigc__p_wxButton,
55062 _swigc__p_wxCURHandler,
55063 _swigc__p_wxCaret,
55064 _swigc__p_wxChildFocusEvent,
55065 _swigc__p_wxClipboardTextEvent,
55066 _swigc__p_wxCloseEvent,
55067 _swigc__p_wxColour,
55068 _swigc__p_wxCommandEvent,
55069 _swigc__p_wxContextMenuEvent,
55070 _swigc__p_wxControl,
55071 _swigc__p_wxControlWithItems,
55072 _swigc__p_wxCursor,
55073 _swigc__p_wxDC,
55074 _swigc__p_wxDateEvent,
55075 _swigc__p_wxDateTime,
55076 _swigc__p_wxDisplayChangedEvent,
55077 _swigc__p_wxDropFilesEvent,
55078 _swigc__p_wxDuplexMode,
55079 _swigc__p_wxEraseEvent,
55080 _swigc__p_wxEvent,
55081 _swigc__p_wxEventLoop,
55082 _swigc__p_wxEventLoopActivator,
55083 _swigc__p_wxEvtHandler,
55084 _swigc__p_wxFSFile,
55085 _swigc__p_wxFileSystem,
55086 _swigc__p_wxFileSystemHandler,
55087 _swigc__p_wxFlexGridSizer,
55088 _swigc__p_wxFocusEvent,
55089 _swigc__p_wxFont,
55090 _swigc__p_wxFrame,
55091 _swigc__p_wxGBPosition,
55092 _swigc__p_wxGBSizerItem,
55093 _swigc__p_wxGBSpan,
55094 _swigc__p_wxGIFHandler,
55095 _swigc__p_wxGridBagSizer,
55096 _swigc__p_wxGridSizer,
55097 _swigc__p_wxHelpEvent__Origin,
55098 _swigc__p_wxICOHandler,
55099 _swigc__p_wxIconizeEvent,
55100 _swigc__p_wxIdleEvent,
55101 _swigc__p_wxImage,
55102 _swigc__p_wxImageHandler,
55103 _swigc__p_wxImageHistogram,
55104 _swigc__p_wxImage_HSVValue,
55105 _swigc__p_wxImage_RGBValue,
55106 _swigc__p_wxIndividualLayoutConstraint,
55107 _swigc__p_wxInitDialogEvent,
55108 _swigc__p_wxInputStream,
55109 _swigc__p_wxInternetFSHandler,
55110 _swigc__p_wxItemContainer,
55111 _swigc__p_wxJPEGHandler,
55112 _swigc__p_wxKeyEvent,
55113 _swigc__p_wxLayoutConstraints,
55114 _swigc__p_wxMaximizeEvent,
55115 _swigc__p_wxMemoryFSHandler,
55116 _swigc__p_wxMenu,
55117 _swigc__p_wxMenuBar,
55118 _swigc__p_wxMenuBarBase,
55119 _swigc__p_wxMenuEvent,
55120 _swigc__p_wxMenuItem,
55121 _swigc__p_wxMouseCaptureChangedEvent,
55122 _swigc__p_wxMouseEvent,
55123 _swigc__p_wxMoveEvent,
55124 _swigc__p_wxNavigationKeyEvent,
55125 _swigc__p_wxNcPaintEvent,
55126 _swigc__p_wxNotifyEvent,
55127 _swigc__p_wxObject,
55128 _swigc__p_wxOutputStream,
55129 _swigc__p_wxPCXHandler,
55130 _swigc__p_wxPNGHandler,
55131 _swigc__p_wxPNMHandler,
55132 _swigc__p_wxPaintEvent,
55133 _swigc__p_wxPaletteChangedEvent,
55134 _swigc__p_wxPaperSize,
55135 _swigc__p_wxPoint,
55136 _swigc__p_wxPoint2D,
55137 _swigc__p_wxPropagateOnce,
55138 _swigc__p_wxPropagationDisabler,
55139 _swigc__p_wxPyApp,
55140 _swigc__p_wxPyCommandEvent,
55141 _swigc__p_wxPyDropTarget,
55142 _swigc__p_wxPyEvent,
55143 _swigc__p_wxPyFileSystemHandler,
55144 _swigc__p_wxPyImageHandler,
55145 _swigc__p_wxPyInputStream,
55146 _swigc__p_wxPySizer,
55147 _swigc__p_wxPyValidator,
55148 _swigc__p_wxQuantize,
55149 _swigc__p_wxQueryNewPaletteEvent,
55150 _swigc__p_wxRealPoint,
55151 _swigc__p_wxRect,
55152 _swigc__p_wxRegion,
55153 _swigc__p_wxScrollEvent,
55154 _swigc__p_wxScrollWinEvent,
55155 _swigc__p_wxSetCursorEvent,
55156 _swigc__p_wxShowEvent,
55157 _swigc__p_wxSize,
55158 _swigc__p_wxSizeEvent,
55159 _swigc__p_wxSizer,
55160 _swigc__p_wxSizerItem,
55161 _swigc__p_wxStaticBox,
55162 _swigc__p_wxStaticBoxSizer,
55163 _swigc__p_wxStdDialogButtonSizer,
55164 _swigc__p_wxSysColourChangedEvent,
55165 _swigc__p_wxTIFFHandler,
55166 _swigc__p_wxToolTip,
55167 _swigc__p_wxUpdateUIEvent,
55168 _swigc__p_wxValidator,
55169 _swigc__p_wxVisualAttributes,
55170 _swigc__p_wxWindow,
55171 _swigc__p_wxWindowCreateEvent,
55172 _swigc__p_wxWindowDestroyEvent,
55173 _swigc__p_wxXPMHandler,
55174 _swigc__p_wxZipFSHandler,
55175 };
55176
55177
55178 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55179
55180 static swig_const_info swig_const_table[] = {
55181 {0, 0, 0, 0.0, 0, 0}};
55182
55183 #ifdef __cplusplus
55184 }
55185 #endif
55186 /* -----------------------------------------------------------------------------
55187 * Type initialization:
55188 * This problem is tough by the requirement that no dynamic
55189 * memory is used. Also, since swig_type_info structures store pointers to
55190 * swig_cast_info structures and swig_cast_info structures store pointers back
55191 * to swig_type_info structures, we need some lookup code at initialization.
55192 * The idea is that swig generates all the structures that are needed.
55193 * The runtime then collects these partially filled structures.
55194 * The SWIG_InitializeModule function takes these initial arrays out of
55195 * swig_module, and does all the lookup, filling in the swig_module.types
55196 * array with the correct data and linking the correct swig_cast_info
55197 * structures together.
55198 *
55199 * The generated swig_type_info structures are assigned staticly to an initial
55200 * array. We just loop though that array, and handle each type individually.
55201 * First we lookup if this type has been already loaded, and if so, use the
55202 * loaded structure instead of the generated one. Then we have to fill in the
55203 * cast linked list. The cast data is initially stored in something like a
55204 * two-dimensional array. Each row corresponds to a type (there are the same
55205 * number of rows as there are in the swig_type_initial array). Each entry in
55206 * a column is one of the swig_cast_info structures for that type.
55207 * The cast_initial array is actually an array of arrays, because each row has
55208 * a variable number of columns. So to actually build the cast linked list,
55209 * we find the array of casts associated with the type, and loop through it
55210 * adding the casts to the list. The one last trick we need to do is making
55211 * sure the type pointer in the swig_cast_info struct is correct.
55212 *
55213 * First off, we lookup the cast->type name to see if it is already loaded.
55214 * There are three cases to handle:
55215 * 1) If the cast->type has already been loaded AND the type we are adding
55216 * casting info to has not been loaded (it is in this module), THEN we
55217 * replace the cast->type pointer with the type pointer that has already
55218 * been loaded.
55219 * 2) If BOTH types (the one we are adding casting info to, and the
55220 * cast->type) are loaded, THEN the cast info has already been loaded by
55221 * the previous module so we just ignore it.
55222 * 3) Finally, if cast->type has not already been loaded, then we add that
55223 * swig_cast_info to the linked list (because the cast->type) pointer will
55224 * be correct.
55225 * ----------------------------------------------------------------------------- */
55226
55227 #ifdef __cplusplus
55228 extern "C" {
55229 #if 0
55230 } /* c-mode */
55231 #endif
55232 #endif
55233
55234 #if 0
55235 #define SWIGRUNTIME_DEBUG
55236 #endif
55237
55238 SWIGRUNTIME void
55239 SWIG_InitializeModule(void *clientdata) {
55240 size_t i;
55241 swig_module_info *module_head;
55242 static int init_run = 0;
55243
55244 clientdata = clientdata;
55245
55246 if (init_run) return;
55247 init_run = 1;
55248
55249 /* Initialize the swig_module */
55250 swig_module.type_initial = swig_type_initial;
55251 swig_module.cast_initial = swig_cast_initial;
55252
55253 /* Try and load any already created modules */
55254 module_head = SWIG_GetModule(clientdata);
55255 if (module_head) {
55256 swig_module.next = module_head->next;
55257 module_head->next = &swig_module;
55258 } else {
55259 /* This is the first module loaded */
55260 swig_module.next = &swig_module;
55261 SWIG_SetModule(clientdata, &swig_module);
55262 }
55263
55264 /* Now work on filling in swig_module.types */
55265 #ifdef SWIGRUNTIME_DEBUG
55266 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55267 #endif
55268 for (i = 0; i < swig_module.size; ++i) {
55269 swig_type_info *type = 0;
55270 swig_type_info *ret;
55271 swig_cast_info *cast;
55272
55273 #ifdef SWIGRUNTIME_DEBUG
55274 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55275 #endif
55276
55277 /* if there is another module already loaded */
55278 if (swig_module.next != &swig_module) {
55279 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55280 }
55281 if (type) {
55282 /* Overwrite clientdata field */
55283 #ifdef SWIGRUNTIME_DEBUG
55284 printf("SWIG_InitializeModule: found type %s\n", type->name);
55285 #endif
55286 if (swig_module.type_initial[i]->clientdata) {
55287 type->clientdata = swig_module.type_initial[i]->clientdata;
55288 #ifdef SWIGRUNTIME_DEBUG
55289 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55290 #endif
55291 }
55292 } else {
55293 type = swig_module.type_initial[i];
55294 }
55295
55296 /* Insert casting types */
55297 cast = swig_module.cast_initial[i];
55298 while (cast->type) {
55299 /* Don't need to add information already in the list */
55300 ret = 0;
55301 #ifdef SWIGRUNTIME_DEBUG
55302 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55303 #endif
55304 if (swig_module.next != &swig_module) {
55305 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55306 #ifdef SWIGRUNTIME_DEBUG
55307 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55308 #endif
55309 }
55310 if (ret) {
55311 if (type == swig_module.type_initial[i]) {
55312 #ifdef SWIGRUNTIME_DEBUG
55313 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55314 #endif
55315 cast->type = ret;
55316 ret = 0;
55317 } else {
55318 /* Check for casting already in the list */
55319 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55320 #ifdef SWIGRUNTIME_DEBUG
55321 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55322 #endif
55323 if (!ocast) ret = 0;
55324 }
55325 }
55326
55327 if (!ret) {
55328 #ifdef SWIGRUNTIME_DEBUG
55329 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55330 #endif
55331 if (type->cast) {
55332 type->cast->prev = cast;
55333 cast->next = type->cast;
55334 }
55335 type->cast = cast;
55336 }
55337 cast++;
55338 }
55339 /* Set entry in modules->types array equal to the type */
55340 swig_module.types[i] = type;
55341 }
55342 swig_module.types[i] = 0;
55343
55344 #ifdef SWIGRUNTIME_DEBUG
55345 printf("**** SWIG_InitializeModule: Cast List ******\n");
55346 for (i = 0; i < swig_module.size; ++i) {
55347 int j = 0;
55348 swig_cast_info *cast = swig_module.cast_initial[i];
55349 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55350 while (cast->type) {
55351 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55352 cast++;
55353 ++j;
55354 }
55355 printf("---- Total casts: %d\n",j);
55356 }
55357 printf("**** SWIG_InitializeModule: Cast List ******\n");
55358 #endif
55359 }
55360
55361 /* This function will propagate the clientdata field of type to
55362 * any new swig_type_info structures that have been added into the list
55363 * of equivalent types. It is like calling
55364 * SWIG_TypeClientData(type, clientdata) a second time.
55365 */
55366 SWIGRUNTIME void
55367 SWIG_PropagateClientData(void) {
55368 size_t i;
55369 swig_cast_info *equiv;
55370 static int init_run = 0;
55371
55372 if (init_run) return;
55373 init_run = 1;
55374
55375 for (i = 0; i < swig_module.size; i++) {
55376 if (swig_module.types[i]->clientdata) {
55377 equiv = swig_module.types[i]->cast;
55378 while (equiv) {
55379 if (!equiv->converter) {
55380 if (equiv->type && !equiv->type->clientdata)
55381 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55382 }
55383 equiv = equiv->next;
55384 }
55385 }
55386 }
55387 }
55388
55389 #ifdef __cplusplus
55390 #if 0
55391 {
55392 /* c-mode */
55393 #endif
55394 }
55395 #endif
55396
55397
55398
55399 #ifdef __cplusplus
55400 extern "C" {
55401 #endif
55402
55403 /* Python-specific SWIG API */
55404 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55405 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55406 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55407
55408 /* -----------------------------------------------------------------------------
55409 * global variable support code.
55410 * ----------------------------------------------------------------------------- */
55411
55412 typedef struct swig_globalvar {
55413 char *name; /* Name of global variable */
55414 PyObject *(*get_attr)(void); /* Return the current value */
55415 int (*set_attr)(PyObject *); /* Set the value */
55416 struct swig_globalvar *next;
55417 } swig_globalvar;
55418
55419 typedef struct swig_varlinkobject {
55420 PyObject_HEAD
55421 swig_globalvar *vars;
55422 } swig_varlinkobject;
55423
55424 SWIGINTERN PyObject *
55425 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55426 return PyString_FromString("<Swig global variables>");
55427 }
55428
55429 SWIGINTERN PyObject *
55430 swig_varlink_str(swig_varlinkobject *v) {
55431 PyObject *str = PyString_FromString("(");
55432 swig_globalvar *var;
55433 for (var = v->vars; var; var=var->next) {
55434 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55435 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55436 }
55437 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55438 return str;
55439 }
55440
55441 SWIGINTERN int
55442 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55443 PyObject *str = swig_varlink_str(v);
55444 fprintf(fp,"Swig global variables ");
55445 fprintf(fp,"%s\n", PyString_AsString(str));
55446 Py_DECREF(str);
55447 return 0;
55448 }
55449
55450 SWIGINTERN void
55451 swig_varlink_dealloc(swig_varlinkobject *v) {
55452 swig_globalvar *var = v->vars;
55453 while (var) {
55454 swig_globalvar *n = var->next;
55455 free(var->name);
55456 free(var);
55457 var = n;
55458 }
55459 }
55460
55461 SWIGINTERN PyObject *
55462 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55463 PyObject *res = NULL;
55464 swig_globalvar *var = v->vars;
55465 while (var) {
55466 if (strcmp(var->name,n) == 0) {
55467 res = (*var->get_attr)();
55468 break;
55469 }
55470 var = var->next;
55471 }
55472 if (res == NULL && !PyErr_Occurred()) {
55473 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55474 }
55475 return res;
55476 }
55477
55478 SWIGINTERN int
55479 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55480 int res = 1;
55481 swig_globalvar *var = v->vars;
55482 while (var) {
55483 if (strcmp(var->name,n) == 0) {
55484 res = (*var->set_attr)(p);
55485 break;
55486 }
55487 var = var->next;
55488 }
55489 if (res == 1 && !PyErr_Occurred()) {
55490 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55491 }
55492 return res;
55493 }
55494
55495 SWIGINTERN PyTypeObject*
55496 swig_varlink_type(void) {
55497 static char varlink__doc__[] = "Swig var link object";
55498 static PyTypeObject varlink_type;
55499 static int type_init = 0;
55500 if (!type_init) {
55501 const PyTypeObject tmp
55502 = {
55503 PyObject_HEAD_INIT(NULL)
55504 0, /* Number of items in variable part (ob_size) */
55505 (char *)"swigvarlink", /* Type name (tp_name) */
55506 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55507 0, /* Itemsize (tp_itemsize) */
55508 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55509 (printfunc) swig_varlink_print, /* Print (tp_print) */
55510 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55511 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55512 0, /* tp_compare */
55513 (reprfunc) swig_varlink_repr, /* tp_repr */
55514 0, /* tp_as_number */
55515 0, /* tp_as_sequence */
55516 0, /* tp_as_mapping */
55517 0, /* tp_hash */
55518 0, /* tp_call */
55519 (reprfunc)swig_varlink_str, /* tp_str */
55520 0, /* tp_getattro */
55521 0, /* tp_setattro */
55522 0, /* tp_as_buffer */
55523 0, /* tp_flags */
55524 varlink__doc__, /* tp_doc */
55525 0, /* tp_traverse */
55526 0, /* tp_clear */
55527 0, /* tp_richcompare */
55528 0, /* tp_weaklistoffset */
55529 #if PY_VERSION_HEX >= 0x02020000
55530 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55531 #endif
55532 #if PY_VERSION_HEX >= 0x02030000
55533 0, /* tp_del */
55534 #endif
55535 #ifdef COUNT_ALLOCS
55536 0,0,0,0 /* tp_alloc -> tp_next */
55537 #endif
55538 };
55539 varlink_type = tmp;
55540 varlink_type.ob_type = &PyType_Type;
55541 type_init = 1;
55542 }
55543 return &varlink_type;
55544 }
55545
55546 /* Create a variable linking object for use later */
55547 SWIGINTERN PyObject *
55548 SWIG_Python_newvarlink(void) {
55549 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55550 if (result) {
55551 result->vars = 0;
55552 }
55553 return ((PyObject*) result);
55554 }
55555
55556 SWIGINTERN void
55557 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55558 swig_varlinkobject *v = (swig_varlinkobject *) p;
55559 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55560 if (gv) {
55561 size_t size = strlen(name)+1;
55562 gv->name = (char *)malloc(size);
55563 if (gv->name) {
55564 strncpy(gv->name,name,size);
55565 gv->get_attr = get_attr;
55566 gv->set_attr = set_attr;
55567 gv->next = v->vars;
55568 }
55569 }
55570 v->vars = gv;
55571 }
55572
55573 SWIGINTERN PyObject *
55574 SWIG_globals() {
55575 static PyObject *_SWIG_globals = 0;
55576 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55577 return _SWIG_globals;
55578 }
55579
55580 /* -----------------------------------------------------------------------------
55581 * constants/methods manipulation
55582 * ----------------------------------------------------------------------------- */
55583
55584 /* Install Constants */
55585 SWIGINTERN void
55586 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55587 PyObject *obj = 0;
55588 size_t i;
55589 for (i = 0; constants[i].type; ++i) {
55590 switch(constants[i].type) {
55591 case SWIG_PY_POINTER:
55592 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55593 break;
55594 case SWIG_PY_BINARY:
55595 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55596 break;
55597 default:
55598 obj = 0;
55599 break;
55600 }
55601 if (obj) {
55602 PyDict_SetItemString(d, constants[i].name, obj);
55603 Py_DECREF(obj);
55604 }
55605 }
55606 }
55607
55608 /* -----------------------------------------------------------------------------*/
55609 /* Fix SwigMethods to carry the callback ptrs when needed */
55610 /* -----------------------------------------------------------------------------*/
55611
55612 SWIGINTERN void
55613 SWIG_Python_FixMethods(PyMethodDef *methods,
55614 swig_const_info *const_table,
55615 swig_type_info **types,
55616 swig_type_info **types_initial) {
55617 size_t i;
55618 for (i = 0; methods[i].ml_name; ++i) {
55619 char *c = methods[i].ml_doc;
55620 if (c && (c = strstr(c, "swig_ptr: "))) {
55621 int j;
55622 swig_const_info *ci = 0;
55623 char *name = c + 10;
55624 for (j = 0; const_table[j].type; ++j) {
55625 if (strncmp(const_table[j].name, name,
55626 strlen(const_table[j].name)) == 0) {
55627 ci = &(const_table[j]);
55628 break;
55629 }
55630 }
55631 if (ci) {
55632 size_t shift = (ci->ptype) - types;
55633 swig_type_info *ty = types_initial[shift];
55634 size_t ldoc = (c - methods[i].ml_doc);
55635 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55636 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55637 if (ndoc) {
55638 char *buff = ndoc;
55639 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55640 if (ptr) {
55641 strncpy(buff, methods[i].ml_doc, ldoc);
55642 buff += ldoc;
55643 strncpy(buff, "swig_ptr: ", 10);
55644 buff += 10;
55645 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55646 methods[i].ml_doc = ndoc;
55647 }
55648 }
55649 }
55650 }
55651 }
55652 }
55653
55654 #ifdef __cplusplus
55655 }
55656 #endif
55657
55658 /* -----------------------------------------------------------------------------*
55659 * Partial Init method
55660 * -----------------------------------------------------------------------------*/
55661
55662 #ifdef __cplusplus
55663 extern "C"
55664 #endif
55665 SWIGEXPORT void SWIG_init(void) {
55666 PyObject *m, *d;
55667
55668 /* Fix SwigMethods to carry the callback ptrs when needed */
55669 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55670
55671 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55672 d = PyModule_GetDict(m);
55673
55674 SWIG_InitializeModule(0);
55675 SWIG_InstallConstants(d,swig_const_table);
55676
55677
55678
55679 #ifndef wxPyUSE_EXPORT
55680 // Make our API structure a CObject so other modules can import it
55681 // from this module.
55682 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55683 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55684 Py_XDECREF(cobj);
55685 #endif
55686
55687 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55688 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55689 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55690 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55691 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55692 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55693 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55694 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55695 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55696 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55697 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55698 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55699 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55700 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55701 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55702 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55703 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55704 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55705 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55706 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55707 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55708 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55709 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
55710 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55711 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55712 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55713 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55714 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55715 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55716 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55717 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55718 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55719 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55720 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55721 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55722 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55723 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55724 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55725 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55726 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55727 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55728 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55729 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55730 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55731 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55732 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55733 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55734 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55735 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55736 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55737 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55738 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55739 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55740 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55741 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55742 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55743 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55744 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55745 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55746 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55747 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55748 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55749 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55750 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55751 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55752 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55753 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55754 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55755 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55756 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55757 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55758 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55759 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55760 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55761 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55762 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55763 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55764 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55765 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55766 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55767 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55768 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55769 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55770 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55771 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55772 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55773 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55774 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55775 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55776 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55777 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55778 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55779 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55780 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55781 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55782 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55783 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55784 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55785 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55786 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55787 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55788 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55789 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55790 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55791 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55792 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55793 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55794 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55795 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55796 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55797 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55798 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55799 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55800 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55801 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55802 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55803 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55804 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55805 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55806 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55807 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55808 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55809 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55810 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55811 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55812 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55813 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55814 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55815 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55816 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55817 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55818 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55819 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55820 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55821 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55822 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55823 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55824 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55825 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55826 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55827 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55828 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55829 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55830 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55831 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55832 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55833 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55834 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55835 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55836 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55837 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55838 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55839 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55840 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55841 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55842 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55843 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55844 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55845 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55846 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55847 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55848 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55849 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55850 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55851 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55852 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55853 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55854 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55855 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55856 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55857 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55858 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55859 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55860 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55861 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55862 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55863 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55864 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55865 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55866 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55867 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55868 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55869 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55870 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55871 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55872 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55873 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55874 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55875 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55876 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55877 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55878 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55879 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55880 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55881 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55882 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55883 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55884 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55885 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55886 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55887 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55888 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55889 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55890 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55891 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55892 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55893 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55894 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55895 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55896 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55897 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55898 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55899 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55900 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55901 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55902 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55903 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55904 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55905 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55906 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55907 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55908 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55909 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55910 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55911 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55912 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55913 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55914 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55915 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55916 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55917 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55918 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55919 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55920 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55921 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55922 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55923 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55924 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55925 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55926 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55927 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55928 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55929 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55930 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55931 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55932 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55933 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55934 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55935 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55936 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55937 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55938 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55939 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55940 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55941 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55942 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55943 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55944 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55945 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55946 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55947 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55948 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55949 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55950 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55951 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55952 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55953 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55954 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55955 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55956 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55957 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55958 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55959 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55960 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55961 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55962 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55963 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55964 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55965 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55966 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55967 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55968 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55969 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55970 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55971 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55972 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55973 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55974 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55975 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55976 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55977 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55978 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55979 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55980 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55981 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55982 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55983 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55984 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55985 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55986 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55987 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55988 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55989 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55990 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55991 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55992 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55993 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55994 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55995 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55996 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55997 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55998 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55999 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56000 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56001 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56002 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56003 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56004 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56005 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56006 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56007 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56008 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56009 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56010 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56011 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56012 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56013 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56014 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56015 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56016 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56017 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56018 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56019 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56020 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56021 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56022 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56023 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56024 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56025 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56026 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56027 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56028 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56029 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56030 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56031 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56032 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56033 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56034 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56035 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56036 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56037 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56038 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56039 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56040 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56041 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56042 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56043 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56044 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56045 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56046 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56047 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56048 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56049 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56050 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56051 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56052 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56053 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56054 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56055 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56056 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56057 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56058 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56059 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56060 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56061 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56062 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56063 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56064 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56065 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56066 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56067 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56068 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56069 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56070 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56071 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56072 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56073 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56074 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56075 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56076 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56077 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56078 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56079 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56080 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56081 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56082 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56083 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56084 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56085 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56086 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56087 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56088 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56089 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56090 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56091 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56092 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56093 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56094 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56095 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56096 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56097 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56098 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56099 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56100 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56101 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56102 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56103 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56104 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56105 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56106 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56107 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56108 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56109 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56110 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56111 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56112 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56113 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56114 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56115 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56116 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56117 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56118 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56119 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56120 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56121 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56122 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56123 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56124 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56125 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56126 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56127 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56128 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56129 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56130 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56131 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56132 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56133 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56134 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56135 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56136 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56137 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56138 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56139 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56140 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56141 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56142 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56143 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56144 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56145 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56146 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56147 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56148 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56149 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56150 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56151 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56152 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56153 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56154 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56155 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56156 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56157 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56158 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56159 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56160 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56161 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56162 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56163 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56164 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56165 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56166 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56167 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56168 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56169 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56170 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56171 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56172 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56173 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56174 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56175 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56176 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56177 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56178 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56179 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56180 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56181 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56182 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56183 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56184 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56185 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56186 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56187 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56188 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56189 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56190 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56191 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56192 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56193 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56194 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56195 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56196 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56197 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56198 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56199 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56200 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56201 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56202 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56203 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56204 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56205 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56206 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56207 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56208 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56209 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56210 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56211 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56212 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56213 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56214 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56215 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56216 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56217 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56218 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56219 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56220 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56221 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56222 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56223 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56224 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56225 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56226 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56227 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56228 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56229 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56230 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56231 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56232 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56233 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56234 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56235 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56236 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56237 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56238 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56239 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56240 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56241 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56242 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56243 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56244 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56245 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56246 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56247 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56248 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56249 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56250 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56251 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56252 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56253 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56254 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56255 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56256 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56257 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56258 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56259 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56260 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56261 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56262 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56263 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56264 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56265 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56266 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56267 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56268 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56269 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56270 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56271 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56272 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56273 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56274 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56275 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56276 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56277 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56278 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56279 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56280 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56281 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56282 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56283 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56284 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56285 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56286 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56287 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56288 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56289 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56290 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56291 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56292 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56293 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56294 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56295 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56296 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56297 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56298 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56299 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56300 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56301 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56302 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56303 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56304 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56305 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56306 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56307 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56308 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56309 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56310 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56311 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56312 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56313 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56314 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56315 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56316 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56317 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56318 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56319 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56320 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56321 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56322 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56323 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56324 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56325 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56326 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56327 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56328 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56329 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56330 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56331 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56332 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56333 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56334 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56335 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56336 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56337 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56338 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56339 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56340 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56341 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56342 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56343 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56344 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56345 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56346 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56347 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56348 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56349 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56350
56351 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56352
56353
56354 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56355
56356 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56357 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56358 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56359 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56360 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56361 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56362 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56363 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56364 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56365 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56366 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56367 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56368 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56369 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56370 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56371 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56372 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56373 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56374 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56375 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56376 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56377 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56378 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56379 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56380 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56381 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56382 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56383 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56384 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56385 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56386 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56387 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56388 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56389 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56390 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56391 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56392 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56393 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56394 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56395 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56396 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56397 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56398 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56399 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56400 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56401 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56402 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56403 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56404 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56405 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56406 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56407 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56408 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56409 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56410 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56411 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56412 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56413 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56414 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56415 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56416 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56417 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56418 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56419 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56420 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56421 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56422 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56423 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56424 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56425 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56426 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56427 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56428 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56429 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56430 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56431 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56432 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56433 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56434 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56435 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56436 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56437 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56438 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56439 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56440 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56441 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56442 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56443 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56444 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56445 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56446 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56447 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56448 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56449 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56450 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56451 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56452 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56453 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56454 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56455 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56456 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56457 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56458 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56459 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56460 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56461 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56462 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56463 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56464 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56465 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56466 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56467 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56468 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56469 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56470 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56471 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56472 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56473 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56474 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56475 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56476 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56477 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56478 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56479 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56480 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56481 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56482 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56483 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56484 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56485 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56486 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56487 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56488 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56489 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56490 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56491 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56492 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56493 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56494 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56495 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56496 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56497 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56498 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56499 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56500 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56501 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56502 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56503 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56504 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56505 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56506 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56507 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56508 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56509 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56510 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56511 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56512 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56513 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56514 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56515 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56516 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56517 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56518 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56519 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56520 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56521 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56522 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56523 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56524 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56525 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56526 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56527 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56528 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56529 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56530 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56531 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56532 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56533 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56534 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56535 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56536 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56537 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56538 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56539 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56540 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56541 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56542 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56543 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56544 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56545 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56546 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56547 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56548 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56549 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56550 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56551 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56552 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56553 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56554 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56555 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56556 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56557 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56558 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56559 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56560 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56561 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56562
56563 // Initialize threading, some globals and such
56564 __wxPyPreStart(d);
56565
56566
56567 // Although these are defined in __version__ they need to be here too so
56568 // that an assert can be done to ensure that the wxPython and the wxWindows
56569 // versions match.
56570 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56571 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56572 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56573
56574 }
56575
wxWidgets (Impactor)