]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
don't throw away the first three stack frames in the assert stack dump (fix needed...
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_buffer swig_types[0]
2463 #define SWIGTYPE_p_char swig_types[1]
2464 #define SWIGTYPE_p_form_ops_t swig_types[2]
2465 #define SWIGTYPE_p_int swig_types[3]
2466 #define SWIGTYPE_p_long swig_types[4]
2467 #define SWIGTYPE_p_unsigned_char swig_types[5]
2468 #define SWIGTYPE_p_unsigned_int swig_types[6]
2469 #define SWIGTYPE_p_unsigned_long swig_types[7]
2470 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2471 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2472 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2473 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2474 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2475 #define SWIGTYPE_p_wxArrayString swig_types[13]
2476 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2477 #define SWIGTYPE_p_wxBitmap swig_types[15]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2479 #define SWIGTYPE_p_wxButton swig_types[17]
2480 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2481 #define SWIGTYPE_p_wxCaret swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxCloseEvent swig_types[21]
2484 #define SWIGTYPE_p_wxColour swig_types[22]
2485 #define SWIGTYPE_p_wxCommandEvent swig_types[23]
2486 #define SWIGTYPE_p_wxContextMenuEvent swig_types[24]
2487 #define SWIGTYPE_p_wxControl swig_types[25]
2488 #define SWIGTYPE_p_wxControlWithItems swig_types[26]
2489 #define SWIGTYPE_p_wxCursor swig_types[27]
2490 #define SWIGTYPE_p_wxDC swig_types[28]
2491 #define SWIGTYPE_p_wxDateEvent swig_types[29]
2492 #define SWIGTYPE_p_wxDateTime swig_types[30]
2493 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[31]
2494 #define SWIGTYPE_p_wxDropFilesEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDuplexMode swig_types[33]
2496 #define SWIGTYPE_p_wxEraseEvent swig_types[34]
2497 #define SWIGTYPE_p_wxEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEventLoop swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoopActivator swig_types[37]
2500 #define SWIGTYPE_p_wxEvtHandler swig_types[38]
2501 #define SWIGTYPE_p_wxFSFile swig_types[39]
2502 #define SWIGTYPE_p_wxFileSystem swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystemHandler swig_types[41]
2504 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
2505 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
2506 #define SWIGTYPE_p_wxFont swig_types[44]
2507 #define SWIGTYPE_p_wxFrame swig_types[45]
2508 #define SWIGTYPE_p_wxGBPosition swig_types[46]
2509 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2510 #define SWIGTYPE_p_wxGBSpan swig_types[48]
2511 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
2512 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
2513 #define SWIGTYPE_p_wxGridSizer swig_types[51]
2514 #define SWIGTYPE_p_wxICOHandler swig_types[52]
2515 #define SWIGTYPE_p_wxIconizeEvent swig_types[53]
2516 #define SWIGTYPE_p_wxIdleEvent swig_types[54]
2517 #define SWIGTYPE_p_wxImage swig_types[55]
2518 #define SWIGTYPE_p_wxImageHandler swig_types[56]
2519 #define SWIGTYPE_p_wxImageHistogram swig_types[57]
2520 #define SWIGTYPE_p_wxImage_HSVValue swig_types[58]
2521 #define SWIGTYPE_p_wxImage_RGBValue swig_types[59]
2522 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[60]
2523 #define SWIGTYPE_p_wxInitDialogEvent swig_types[61]
2524 #define SWIGTYPE_p_wxInputStream swig_types[62]
2525 #define SWIGTYPE_p_wxInternetFSHandler swig_types[63]
2526 #define SWIGTYPE_p_wxItemContainer swig_types[64]
2527 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
2528 #define SWIGTYPE_p_wxKeyEvent swig_types[66]
2529 #define SWIGTYPE_p_wxLayoutConstraints swig_types[67]
2530 #define SWIGTYPE_p_wxMaximizeEvent swig_types[68]
2531 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
2532 #define SWIGTYPE_p_wxMenu swig_types[70]
2533 #define SWIGTYPE_p_wxMenuBar swig_types[71]
2534 #define SWIGTYPE_p_wxMenuBarBase swig_types[72]
2535 #define SWIGTYPE_p_wxMenuEvent swig_types[73]
2536 #define SWIGTYPE_p_wxMenuItem swig_types[74]
2537 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[75]
2538 #define SWIGTYPE_p_wxMouseEvent swig_types[76]
2539 #define SWIGTYPE_p_wxMoveEvent swig_types[77]
2540 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[78]
2541 #define SWIGTYPE_p_wxNcPaintEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNotifyEvent swig_types[80]
2543 #define SWIGTYPE_p_wxObject swig_types[81]
2544 #define SWIGTYPE_p_wxOutputStream swig_types[82]
2545 #define SWIGTYPE_p_wxPCXHandler swig_types[83]
2546 #define SWIGTYPE_p_wxPNGHandler swig_types[84]
2547 #define SWIGTYPE_p_wxPNMHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPaintEvent swig_types[86]
2549 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[87]
2550 #define SWIGTYPE_p_wxPaperSize swig_types[88]
2551 #define SWIGTYPE_p_wxPoint swig_types[89]
2552 #define SWIGTYPE_p_wxPoint2D swig_types[90]
2553 #define SWIGTYPE_p_wxPropagateOnce swig_types[91]
2554 #define SWIGTYPE_p_wxPropagationDisabler swig_types[92]
2555 #define SWIGTYPE_p_wxPyApp swig_types[93]
2556 #define SWIGTYPE_p_wxPyCommandEvent swig_types[94]
2557 #define SWIGTYPE_p_wxPyDropTarget swig_types[95]
2558 #define SWIGTYPE_p_wxPyEvent swig_types[96]
2559 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[97]
2560 #define SWIGTYPE_p_wxPyImageHandler swig_types[98]
2561 #define SWIGTYPE_p_wxPyInputStream swig_types[99]
2562 #define SWIGTYPE_p_wxPySizer swig_types[100]
2563 #define SWIGTYPE_p_wxPyValidator swig_types[101]
2564 #define SWIGTYPE_p_wxQuantize swig_types[102]
2565 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[103]
2566 #define SWIGTYPE_p_wxRealPoint swig_types[104]
2567 #define SWIGTYPE_p_wxRect swig_types[105]
2568 #define SWIGTYPE_p_wxRegion swig_types[106]
2569 #define SWIGTYPE_p_wxScrollEvent swig_types[107]
2570 #define SWIGTYPE_p_wxScrollWinEvent swig_types[108]
2571 #define SWIGTYPE_p_wxSetCursorEvent swig_types[109]
2572 #define SWIGTYPE_p_wxShowEvent swig_types[110]
2573 #define SWIGTYPE_p_wxSize swig_types[111]
2574 #define SWIGTYPE_p_wxSizeEvent swig_types[112]
2575 #define SWIGTYPE_p_wxSizer swig_types[113]
2576 #define SWIGTYPE_p_wxSizerItem swig_types[114]
2577 #define SWIGTYPE_p_wxStaticBox swig_types[115]
2578 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[116]
2579 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[117]
2580 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[118]
2581 #define SWIGTYPE_p_wxTIFFHandler swig_types[119]
2582 #define SWIGTYPE_p_wxToolTip swig_types[120]
2583 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[121]
2584 #define SWIGTYPE_p_wxValidator swig_types[122]
2585 #define SWIGTYPE_p_wxVisualAttributes swig_types[123]
2586 #define SWIGTYPE_p_wxWindow swig_types[124]
2587 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[125]
2588 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[126]
2589 #define SWIGTYPE_p_wxXPMHandler swig_types[127]
2590 #define SWIGTYPE_p_wxZipFSHandler swig_types[128]
2591 static swig_type_info *swig_types[130];
2592 static swig_module_info swig_module = {swig_types, 129, 0, 0, 0, 0};
2593 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2594 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2595
2596 /* -------- TYPES TABLE (END) -------- */
2597
2598 #if (PY_VERSION_HEX <= 0x02000000)
2599 # if !defined(SWIG_PYTHON_CLASSIC)
2600 # error "This python version requires to use swig with the '-classic' option"
2601 # endif
2602 #endif
2603 #if (PY_VERSION_HEX <= 0x02020000)
2604 # error "This python version requires to use swig with the '-nomodern' option"
2605 #endif
2606 #if (PY_VERSION_HEX <= 0x02020000)
2607 # error "This python version requires to use swig with the '-nomodernargs' option"
2608 #endif
2609 #ifndef METH_O
2610 # error "This python version requires to use swig with the '-nofastunpack' option"
2611 #endif
2612
2613 /*-----------------------------------------------
2614 @(target):= _core_.so
2615 ------------------------------------------------*/
2616 #define SWIG_init init_core_
2617
2618 #define SWIG_name "_core_"
2619
2620 #define SWIGVERSION 0x010329
2621
2622
2623 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2624 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2625
2626
2627 #include <stdexcept>
2628
2629
2630 namespace swig {
2631 class PyObject_ptr {
2632 protected:
2633 PyObject *_obj;
2634
2635 public:
2636 PyObject_ptr() :_obj(0)
2637 {
2638 }
2639
2640 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2641 {
2642 Py_XINCREF(_obj);
2643 }
2644
2645 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2646 {
2647 if (initial_ref) Py_XINCREF(_obj);
2648 }
2649
2650 PyObject_ptr & operator=(const PyObject_ptr& item)
2651 {
2652 Py_XINCREF(item._obj);
2653 Py_XDECREF(_obj);
2654 _obj = item._obj;
2655 return *this;
2656 }
2657
2658 ~PyObject_ptr()
2659 {
2660 Py_XDECREF(_obj);
2661 }
2662
2663 operator PyObject *() const
2664 {
2665 return _obj;
2666 }
2667
2668 PyObject *operator->() const
2669 {
2670 return _obj;
2671 }
2672 };
2673 }
2674
2675
2676 namespace swig {
2677 struct PyObject_var : PyObject_ptr {
2678 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2679
2680 PyObject_var & operator = (PyObject* obj)
2681 {
2682 Py_XDECREF(_obj);
2683 _obj = obj;
2684 return *this;
2685 }
2686 };
2687 }
2688
2689
2690 #include "wx/wxPython/wxPython_int.h"
2691 #include "wx/wxPython/pyclasses.h"
2692
2693
2694 #ifndef wxPyUSE_EXPORT
2695 // Helper functions for dealing with SWIG objects and such. These are
2696 // located here so they know about the SWIG types and functions declared
2697 // in the wrapper code.
2698
2699 #include <wx/hashmap.h>
2700 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2701
2702
2703 // Maintains a hashmap of className to swig_type_info pointers. Given the
2704 // name of a class either looks up the type info in the cache, or scans the
2705 // SWIG tables for it.
2706 extern PyObject* wxPyPtrTypeMap;
2707 static
2708 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2709
2710 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2711
2712 if (typeInfoCache == NULL)
2713 typeInfoCache = new wxPyTypeInfoHashMap;
2714
2715 wxString name(className);
2716 swig_type_info* swigType = (*typeInfoCache)[name];
2717
2718 if (! swigType) {
2719 // it wasn't in the cache, so look it up from SWIG
2720 name.Append(wxT(" *"));
2721 swigType = SWIG_TypeQuery(name.mb_str());
2722
2723 // if it still wasn't found, try looking for a mapped name
2724 if (!swigType) {
2725 PyObject* item;
2726 name = className;
2727
2728 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2729 (char*)(const char*)name.mbc_str())) != NULL) {
2730 name = wxString(PyString_AsString(item), *wxConvCurrent);
2731 name.Append(wxT(" *"));
2732 swigType = SWIG_TypeQuery(name.mb_str());
2733 }
2734 }
2735 if (swigType) {
2736 // and add it to the map if found
2737 (*typeInfoCache)[className] = swigType;
2738 }
2739 }
2740 return swigType;
2741 }
2742
2743
2744 // Check if a class name is a type known to SWIG
2745 bool wxPyCheckSwigType(const wxChar* className) {
2746
2747 swig_type_info* swigType = wxPyFindSwigType(className);
2748 return swigType != NULL;
2749 }
2750
2751
2752 // Given a pointer to a C++ object and a class name, construct a Python proxy
2753 // object for it.
2754 PyObject* wxPyConstructObject(void* ptr,
2755 const wxChar* className,
2756 int setThisOwn) {
2757
2758 swig_type_info* swigType = wxPyFindSwigType(className);
2759 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2760
2761 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2762 }
2763
2764
2765 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2766 // Ensures that the proxy object is of the specified (or derived) type. If
2767 // not able to perform the conversion then a Python exception is set and the
2768 // error should be handled properly in the caller. Returns True on success.
2769 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2770 const wxChar* className) {
2771
2772 swig_type_info* swigType = wxPyFindSwigType(className);
2773 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2774
2775 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2776 }
2777
2778
2779
2780 // Make a SWIGified pointer object suitable for a .this attribute
2781 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2782
2783 PyObject* robj = NULL;
2784
2785 swig_type_info* swigType = wxPyFindSwigType(className);
2786 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2787
2788 robj = PySwigObject_New(ptr, swigType, 0);
2789 return robj;
2790 }
2791
2792
2793 // Python's PyInstance_Check does not return True for instances of new-style
2794 // classes. This should get close enough for both new and old classes but I
2795 // should re-evaluate the need for doing instance checks...
2796 bool wxPyInstance_Check(PyObject* obj) {
2797 return PyObject_HasAttrString(obj, "__class__") != 0;
2798 }
2799
2800
2801 // This one checks if the object is an instance of a SWIG proxy class (it has
2802 // a .this attribute, and the .this attribute is a PySwigObject.)
2803 bool wxPySwigInstance_Check(PyObject* obj) {
2804 static PyObject* this_str = NULL;
2805 if (this_str == NULL)
2806 this_str = PyString_FromString("this");
2807
2808 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2809 if (this_attr) {
2810 bool retval = (PySwigObject_Check(this_attr) != 0);
2811 Py_DECREF(this_attr);
2812 return retval;
2813 }
2814
2815 PyErr_Clear();
2816 return false;
2817 }
2818
2819
2820 // Export a C API in a struct. Other modules will be able to load this from
2821 // the wx._core_ module and will then have safe access to these functions,
2822 // even if they are located in another shared library.
2823 static wxPyCoreAPI API = {
2824
2825 wxPyCheckSwigType,
2826 wxPyConstructObject,
2827 wxPyConvertSwigPtr,
2828 wxPyMakeSwigPtr,
2829
2830 wxPyBeginAllowThreads,
2831 wxPyEndAllowThreads,
2832 wxPyBeginBlockThreads,
2833 wxPyEndBlockThreads,
2834
2835 wxPy_ConvertList,
2836
2837 wxString_in_helper,
2838 Py2wxString,
2839 wx2PyString,
2840
2841 byte_LIST_helper,
2842 int_LIST_helper,
2843 long_LIST_helper,
2844 string_LIST_helper,
2845 wxPoint_LIST_helper,
2846 wxBitmap_LIST_helper,
2847 wxString_LIST_helper,
2848 wxAcceleratorEntry_LIST_helper,
2849
2850 wxSize_helper,
2851 wxPoint_helper,
2852 wxRealPoint_helper,
2853 wxRect_helper,
2854 wxColour_helper,
2855 wxPoint2D_helper,
2856
2857 wxPySimple_typecheck,
2858 wxColour_typecheck,
2859
2860 wxPyCBH_setCallbackInfo,
2861 wxPyCBH_findCallback,
2862 wxPyCBH_callCallback,
2863 wxPyCBH_callCallbackObj,
2864 wxPyCBH_delete,
2865
2866 wxPyMake_wxObject,
2867 wxPyMake_wxSizer,
2868 wxPyPtrTypeMap_Add,
2869 wxPy2int_seq_helper,
2870 wxPy4int_seq_helper,
2871 wxArrayString2PyList_helper,
2872 wxArrayInt2PyList_helper,
2873
2874 wxPyClientData_dtor,
2875 wxPyUserData_dtor,
2876 wxPyOORClientData_dtor,
2877
2878 wxPyCBInputStream_create,
2879 wxPyCBInputStream_copy,
2880
2881 wxPyInstance_Check,
2882 wxPySwigInstance_Check,
2883
2884 wxPyCheckForApp
2885
2886 };
2887
2888 #endif
2889
2890
2891 #if !WXWIN_COMPATIBILITY_2_4
2892 #define wxHIDE_READONLY 0
2893 #endif
2894
2895
2896 #define SWIG_From_long PyInt_FromLong
2897
2898
2899 SWIGINTERNINLINE PyObject *
2900 SWIG_From_int (int value)
2901 {
2902 return SWIG_From_long (value);
2903 }
2904
2905 static const wxString wxPyEmptyString(wxEmptyString);
2906 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2907 return self->GetClassInfo()->GetClassName();
2908 }
2909 SWIGINTERN void wxObject_Destroy(wxObject *self){
2910 delete self;
2911 }
2912
2913 #ifndef __WXMAC__
2914 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2915 #endif
2916
2917
2918 #include <limits.h>
2919 #ifndef LLONG_MIN
2920 # define LLONG_MIN LONG_LONG_MIN
2921 #endif
2922 #ifndef LLONG_MAX
2923 # define LLONG_MAX LONG_LONG_MAX
2924 #endif
2925 #ifndef ULLONG_MAX
2926 # define ULLONG_MAX ULONG_LONG_MAX
2927 #endif
2928
2929
2930 SWIGINTERN int
2931 SWIG_AsVal_long (PyObject* obj, long* val)
2932 {
2933 if (PyNumber_Check(obj)) {
2934 if (val) *val = PyInt_AsLong(obj);
2935 return SWIG_OK;
2936 }
2937 return SWIG_TypeError;
2938 }
2939
2940
2941 SWIGINTERN int
2942 SWIG_AsVal_int (PyObject * obj, int *val)
2943 {
2944 long v;
2945 int res = SWIG_AsVal_long (obj, &v);
2946 if (SWIG_IsOK(res)) {
2947 if ((v < INT_MIN || v > INT_MAX)) {
2948 return SWIG_OverflowError;
2949 } else {
2950 if (val) *val = static_cast< int >(v);
2951 }
2952 }
2953 return res;
2954 }
2955
2956 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2957 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2958 PyObject* tup = PyTuple_New(2);
2959 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2960 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2961 wxPyEndBlockThreads(blocked);
2962 return tup;
2963 }
2964
2965 SWIGINTERN int
2966 SWIG_AsVal_double (PyObject *obj, double* val)
2967 {
2968 if (PyNumber_Check(obj)) {
2969 if (val) *val = PyFloat_AsDouble(obj);
2970 return SWIG_OK;
2971 }
2972 return SWIG_TypeError;
2973 }
2974
2975
2976 #define SWIG_From_double PyFloat_FromDouble
2977
2978 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
2979 self->x = x;
2980 self->y = y;
2981 }
2982 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
2983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2984 PyObject* tup = PyTuple_New(2);
2985 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
2986 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
2987 wxPyEndBlockThreads(blocked);
2988 return tup;
2989 }
2990 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
2991 self->x = x;
2992 self->y = y;
2993 }
2994 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
2995 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2996 PyObject* tup = PyTuple_New(2);
2997 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2998 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2999 wxPyEndBlockThreads(blocked);
3000 return tup;
3001 }
3002 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3003 self->x = x;
3004 self->y = y;
3005 self->width = width;
3006 self->height = height;
3007 }
3008 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3009 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3010 PyObject* tup = PyTuple_New(4);
3011 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3012 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3013 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3014 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3015 wxPyEndBlockThreads(blocked);
3016 return tup;
3017 }
3018
3019 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3020 wxRegion reg1(*r1);
3021 wxRegion reg2(*r2);
3022 wxRect dest(0,0,0,0);
3023 PyObject* obj;
3024
3025 reg1.Intersect(reg2);
3026 dest = reg1.GetBox();
3027
3028 if (dest != wxRect(0,0,0,0)) {
3029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3030 wxRect* newRect = new wxRect(dest);
3031 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3032 wxPyEndBlockThreads(blocked);
3033 return obj;
3034 }
3035 Py_INCREF(Py_None);
3036 return Py_None;
3037 }
3038
3039 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3040 self->m_x = x;
3041 self->m_y = y;
3042 }
3043 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3044 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3045 PyObject* tup = PyTuple_New(2);
3046 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3047 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3048 wxPyEndBlockThreads(blocked);
3049 return tup;
3050 }
3051
3052 #include "wx/wxPython/pyistream.h"
3053
3054 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3055 wxInputStream* wxis = wxPyCBInputStream::create(p);
3056 if (wxis)
3057 return new wxPyInputStream(wxis);
3058 else
3059 return NULL;
3060 }
3061
3062 SWIGINTERN swig_type_info*
3063 SWIG_pchar_descriptor()
3064 {
3065 static int init = 0;
3066 static swig_type_info* info = 0;
3067 if (!init) {
3068 info = SWIG_TypeQuery("_p_char");
3069 init = 1;
3070 }
3071 return info;
3072 }
3073
3074
3075 SWIGINTERNINLINE PyObject *
3076 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3077 {
3078 if (carray) {
3079 if (size > INT_MAX) {
3080 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3081 return pchar_descriptor ?
3082 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3083 } else {
3084 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3085 }
3086 } else {
3087 return SWIG_Py_Void();
3088 }
3089 }
3090
3091
3092 SWIGINTERNINLINE PyObject *
3093 SWIG_From_char (char c)
3094 {
3095 return SWIG_FromCharPtrAndSize(&c,1);
3096 }
3097
3098
3099 SWIGINTERNINLINE PyObject*
3100 SWIG_From_unsigned_SS_long (unsigned long value)
3101 {
3102 return (value > LONG_MAX) ?
3103 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3104 }
3105
3106
3107 SWIGINTERNINLINE PyObject *
3108 SWIG_From_size_t (size_t value)
3109 {
3110 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3111 }
3112
3113
3114 SWIGINTERN int
3115 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3116 {
3117 if (PyString_Check(obj)) {
3118 char *cstr; int len;
3119 PyString_AsStringAndSize(obj, &cstr, &len);
3120 if (cptr) {
3121 if (alloc) {
3122 /*
3123 In python the user should not be able to modify the inner
3124 string representation. To warranty that, if you define
3125 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3126 buffer is always returned.
3127
3128 The default behavior is just to return the pointer value,
3129 so, be careful.
3130 */
3131 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3132 if (*alloc != SWIG_OLDOBJ)
3133 #else
3134 if (*alloc == SWIG_NEWOBJ)
3135 #endif
3136 {
3137 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3138 *alloc = SWIG_NEWOBJ;
3139 }
3140 else {
3141 *cptr = cstr;
3142 *alloc = SWIG_OLDOBJ;
3143 }
3144 } else {
3145 *cptr = PyString_AsString(obj);
3146 }
3147 }
3148 if (psize) *psize = len + 1;
3149 return SWIG_OK;
3150 } else {
3151 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3152 if (pchar_descriptor) {
3153 void* vptr = 0;
3154 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3155 if (cptr) *cptr = (char *) vptr;
3156 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3157 if (alloc) *alloc = SWIG_OLDOBJ;
3158 return SWIG_OK;
3159 }
3160 }
3161 }
3162 return SWIG_TypeError;
3163 }
3164
3165
3166 SWIGINTERN int
3167 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3168 {
3169 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3170 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3171 if (SWIG_IsOK(res)) {
3172 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3173 if (csize <= size) {
3174 if (val) {
3175 if (csize) memcpy(val, cptr, csize*sizeof(char));
3176 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3177 }
3178 if (alloc == SWIG_NEWOBJ) {
3179 delete[] cptr;
3180 res = SWIG_DelNewMask(res);
3181 }
3182 return res;
3183 }
3184 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3185 }
3186 return SWIG_TypeError;
3187 }
3188
3189
3190 SWIGINTERN int
3191 SWIG_AsVal_char (PyObject * obj, char *val)
3192 {
3193 int res = SWIG_AsCharArray(obj, val, 1);
3194 if (!SWIG_IsOK(res)) {
3195 long v;
3196 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3197 if (SWIG_IsOK(res)) {
3198 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3199 if (val) *val = static_cast< char >(v);
3200 } else {
3201 res = SWIG_OverflowError;
3202 }
3203 }
3204 }
3205 return res;
3206 }
3207
3208 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3209 // We use only strings for the streams, not unicode
3210 PyObject* str = PyObject_Str(obj);
3211 if (! str) {
3212 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3213 return;
3214 }
3215 self->Write(PyString_AS_STRING(str),
3216 PyString_GET_SIZE(str));
3217 Py_DECREF(str);
3218 }
3219
3220 #include "wx/wxPython/pyistream.h"
3221
3222
3223 class wxPyFileSystemHandler : public wxFileSystemHandler
3224 {
3225 public:
3226 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3227
3228 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3229 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3230 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3231 DEC_PYCALLBACK_STRING__pure(FindNext);
3232
3233 wxString GetProtocol(const wxString& location) {
3234 return wxFileSystemHandler::GetProtocol(location);
3235 }
3236
3237 wxString GetLeftLocation(const wxString& location) {
3238 return wxFileSystemHandler::GetLeftLocation(location);
3239 }
3240
3241 wxString GetAnchor(const wxString& location) {
3242 return wxFileSystemHandler::GetAnchor(location);
3243 }
3244
3245 wxString GetRightLocation(const wxString& location) {
3246 return wxFileSystemHandler::GetRightLocation(location);
3247 }
3248
3249 wxString GetMimeTypeFromExt(const wxString& location) {
3250 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3251 }
3252
3253 PYPRIVATE;
3254 };
3255
3256
3257 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3258 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3259 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3260 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3261
3262
3263 SWIGINTERN int
3264 SWIG_AsVal_bool (PyObject *obj, bool *val)
3265 {
3266 if (obj == Py_True) {
3267 if (val) *val = true;
3268 return SWIG_OK;
3269 } else if (obj == Py_False) {
3270 if (val) *val = false;
3271 return SWIG_OK;
3272 } else {
3273 long v = 0;
3274 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3275 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3276 return res;
3277 }
3278 }
3279
3280 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3281 wxFileName fname = wxFileSystem::URLToFileName(url);
3282 return fname.GetFullPath();
3283 }
3284
3285 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3286 wxImage& image,
3287 long type) {
3288 wxMemoryFSHandler::AddFile(filename, image, type);
3289 }
3290
3291 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3292 const wxBitmap& bitmap,
3293 long type) {
3294 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3295 }
3296
3297 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3298 PyObject* data) {
3299 if (! PyString_Check(data)) {
3300 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3301 "Expected string object"));
3302 return;
3303 }
3304
3305 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3306 void* ptr = (void*)PyString_AsString(data);
3307 size_t size = PyString_Size(data);
3308 wxPyEndBlockThreads(blocked);
3309
3310 wxMemoryFSHandler::AddFile(filename, ptr, size);
3311 }
3312
3313
3314 #include "wx/wxPython/pyistream.h"
3315
3316
3317 SWIGINTERN int
3318 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3319 {
3320 long v = 0;
3321 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3322 return SWIG_TypeError;
3323 }
3324 else if (val)
3325 *val = (unsigned long)v;
3326 return SWIG_OK;
3327 }
3328
3329
3330 SWIGINTERN int
3331 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3332 {
3333 unsigned long v;
3334 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3335 if (SWIG_IsOK(res)) {
3336 if ((v > UCHAR_MAX)) {
3337 return SWIG_OverflowError;
3338 } else {
3339 if (val) *val = static_cast< unsigned char >(v);
3340 }
3341 }
3342 return res;
3343 }
3344
3345
3346 SWIGINTERNINLINE PyObject *
3347 SWIG_From_unsigned_SS_char (unsigned char value)
3348 {
3349 return SWIG_From_unsigned_SS_long (value);
3350 }
3351
3352 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3353 wxImageHistogramEntry e = (*self)[key];
3354 return e.value;
3355 }
3356 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3357 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3358 wxImageHistogramEntry e = (*self)[key];
3359 return e.value;
3360 }
3361 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3362 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3363 colour.Green(),
3364 colour.Blue());
3365 wxImageHistogramEntry e = (*self)[key];
3366 return e.value;
3367 }
3368
3369 typedef unsigned char* buffer;
3370
3371
3372 // Pull the nested class out to the top level for SWIG's sake
3373 #define wxImage_RGBValue wxImage::RGBValue
3374 #define wxImage_HSVValue wxImage::HSVValue
3375
3376 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3377 if (width > 0 && height > 0)
3378 return new wxImage(width, height, clear);
3379 else
3380 return new wxImage;
3381 }
3382 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3383 return new wxImage(bitmap.ConvertToImage());
3384 }
3385 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3386 if (DATASIZE != width*height*3) {
3387 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3388 return NULL;
3389 }
3390
3391 // Copy the source data so the wxImage can clean it up later
3392 buffer copy = (buffer)malloc(DATASIZE);
3393 if (copy == NULL) {
3394 wxPyBLOCK_THREADS(PyErr_NoMemory());
3395 return NULL;
3396 }
3397 memcpy(copy, data, DATASIZE);
3398 return new wxImage(width, height, copy, false);
3399 }
3400 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3401 if (DATASIZE != width*height*3) {
3402 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3403 return NULL;
3404 }
3405 if (ALPHASIZE != width*height) {
3406 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3407 return NULL;
3408 }
3409
3410 // Copy the source data so the wxImage can clean it up later
3411 buffer dcopy = (buffer)malloc(DATASIZE);
3412 if (dcopy == NULL) {
3413 wxPyBLOCK_THREADS(PyErr_NoMemory());
3414 return NULL;
3415 }
3416 memcpy(dcopy, data, DATASIZE);
3417
3418 buffer acopy = (buffer)malloc(ALPHASIZE);
3419 if (acopy == NULL) {
3420 wxPyBLOCK_THREADS(PyErr_NoMemory());
3421 return NULL;
3422 }
3423 memcpy(acopy, alpha, ALPHASIZE);
3424
3425 return new wxImage(width, height, dcopy, acopy, false);
3426 }
3427 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3428 wxSize size(self->GetWidth(), self->GetHeight());
3429 return size;
3430 }
3431 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3432 buffer data = self->GetData();
3433 int len = self->GetWidth() * self->GetHeight() * 3;
3434 PyObject* rv;
3435 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3436 return rv;
3437 }
3438 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3439 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3440 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3441 return;
3442 }
3443 buffer copy = (buffer)malloc(DATASIZE);
3444 if (copy == NULL) {
3445 wxPyBLOCK_THREADS(PyErr_NoMemory());
3446 return;
3447 }
3448 memcpy(copy, data, DATASIZE);
3449 self->SetData(copy, false);
3450 // wxImage takes ownership of copy...
3451 }
3452 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3453 buffer data = self->GetData();
3454 int len = self->GetWidth() * self->GetHeight() * 3;
3455 PyObject* rv;
3456 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3457 return rv;
3458 }
3459 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3460 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3461 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3462 return;
3463 }
3464 self->SetData(data, true);
3465 }
3466 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3467 buffer data = self->GetAlpha();
3468 if (! data) {
3469 RETURN_NONE();
3470 } else {
3471 int len = self->GetWidth() * self->GetHeight();
3472 PyObject* rv;
3473 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3474 return rv;
3475 }
3476 }
3477 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3478 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3479 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3480 return;
3481 }
3482 buffer acopy = (buffer)malloc(ALPHASIZE);
3483 if (acopy == NULL) {
3484 wxPyBLOCK_THREADS(PyErr_NoMemory());
3485 return;
3486 }
3487 memcpy(acopy, alpha, ALPHASIZE);
3488 self->SetAlpha(acopy, false);
3489 // wxImage takes ownership of acopy...
3490 }
3491 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3492 buffer data = self->GetAlpha();
3493 int len = self->GetWidth() * self->GetHeight();
3494 PyObject* rv;
3495 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3496 return rv;
3497 }
3498 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3499 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3500 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3501 return;
3502 }
3503 self->SetAlpha(alpha, true);
3504 }
3505 SWIGINTERN PyObject *wxImage_GetHandlers(){
3506 wxList& list = wxImage::GetHandlers();
3507 return wxPy_ConvertList(&list);
3508 }
3509 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3510 wxBitmap bitmap(*self, depth);
3511 return bitmap;
3512 }
3513 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3514 wxImage mono = self->ConvertToMono( red, green, blue );
3515 wxBitmap bitmap( mono, 1 );
3516 return bitmap;
3517 }
3518 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3519 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3520 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3521 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3522 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3523 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3524 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3525 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3526 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3527 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3528 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3529 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3530 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3531 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3532 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3533
3534 #include <wx/quantize.h>
3535
3536 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3537 return wxQuantize::Quantize(src, dest,
3538 //NULL, // palette
3539 desiredNoColours,
3540 NULL, // eightBitData
3541 flags);
3542 }
3543 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3544 if (PyCallable_Check(func)) {
3545 self->Connect(id, lastId, eventType,
3546 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3547 new wxPyCallback(func));
3548 }
3549 else if (func == Py_None) {
3550 self->Disconnect(id, lastId, eventType,
3551 (wxObjectEventFunction)
3552 &wxPyCallback::EventThunker);
3553 }
3554 else {
3555 wxPyBLOCK_THREADS(
3556 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3557 }
3558 }
3559 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3560 return self->Disconnect(id, lastId, eventType,
3561 (wxObjectEventFunction)
3562 &wxPyCallback::EventThunker);
3563 }
3564 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3565 if (_self && _self != Py_None) {
3566 self->SetClientObject(new wxPyOORClientData(_self, incref));
3567 }
3568 else {
3569 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3570 if (data) {
3571 self->SetClientObject(NULL); // This will delete it too
3572 }
3573 }
3574 }
3575
3576 #if ! wxUSE_HOTKEY
3577 #define wxEVT_HOTKEY -9999
3578 #endif
3579
3580 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3581 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3582 if (data) {
3583 Py_INCREF(data->m_obj);
3584 return data->m_obj;
3585 } else {
3586 Py_INCREF(Py_None);
3587 return Py_None;
3588 }
3589 }
3590 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3591 wxPyClientData* data = new wxPyClientData(clientData);
3592 self->SetClientObject(data);
3593 }
3594 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3595 #if wxUSE_UNICODE
3596 return self->GetUnicodeKey();
3597 #else
3598 return 0;
3599 #endif
3600 }
3601
3602 SWIGINTERNINLINE PyObject *
3603 SWIG_From_unsigned_SS_int (unsigned int value)
3604 {
3605 return SWIG_From_unsigned_SS_long (value);
3606 }
3607
3608
3609 SWIGINTERN int
3610 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3611 {
3612 unsigned long v;
3613 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3614 if (SWIG_IsOK(res)) {
3615 if ((v > UINT_MAX)) {
3616 return SWIG_OverflowError;
3617 } else {
3618 if (val) *val = static_cast< unsigned int >(v);
3619 }
3620 }
3621 return res;
3622 }
3623
3624 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3625 self->m_size = size;
3626 }
3627 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3628 int count = self->GetNumberOfFiles();
3629 wxString* files = self->GetFiles();
3630 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3631 PyObject* list = PyList_New(count);
3632
3633 if (!list) {
3634 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3635 wxPyEndBlockThreads(blocked);
3636 return NULL;
3637 }
3638
3639 for (int i=0; i<count; i++) {
3640 PyList_SetItem(list, i, wx2PyString(files[i]));
3641 }
3642 wxPyEndBlockThreads(blocked);
3643 return list;
3644 }
3645
3646
3647 SWIGINTERN wxPyApp *new_wxPyApp(){
3648 wxPythonApp = new wxPyApp();
3649 return wxPythonApp;
3650 }
3651 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3652
3653 void wxApp_CleanUp() {
3654 __wxPyCleanup();
3655 }
3656
3657
3658 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3659
3660
3661
3662
3663
3664 SWIGINTERNINLINE PyObject *
3665 SWIG_FromCharPtr(const char *cptr)
3666 {
3667 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3668 }
3669
3670
3671 #if 0 // #ifdef __WXMAC__
3672
3673 // A dummy class that raises an exception if used...
3674 class wxEventLoop
3675 {
3676 public:
3677 wxEventLoop() { wxPyRaiseNotImplemented(); }
3678 int Run() { return 0; }
3679 void Exit(int rc = 0) {}
3680 bool Pending() const { return false; }
3681 bool Dispatch() { return false; }
3682 bool IsRunning() const { return false; }
3683 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3684 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3685 };
3686
3687 #else
3688
3689 #include <wx/evtloop.h>
3690
3691 #endif
3692
3693
3694
3695 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3696 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3697 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3698 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3699 wxWindowList& list = self->GetChildren();
3700 return wxPy_ConvertList(&list);
3701 }
3702 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3703 #if wxUSE_HOTKEY
3704 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3705 #else
3706 return false;
3707 #endif
3708 }
3709 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3710
3711
3712
3713 return false;
3714
3715 }
3716 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3717 return wxPyGetWinHandle(self);
3718 }
3719 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3720 self->AssociateHandle((WXWidget)handle);
3721 }
3722 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3723
3724 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3725 return wxWindow::FindWindowById(id, parent);
3726 }
3727
3728 wxWindow* wxFindWindowByName( const wxString& name,
3729 const wxWindow *parent = NULL ) {
3730 return wxWindow::FindWindowByName(name, parent);
3731 }
3732
3733 wxWindow* wxFindWindowByLabel( const wxString& label,
3734 const wxWindow *parent = NULL ) {
3735 return wxWindow::FindWindowByLabel(label, parent);
3736 }
3737
3738
3739 #ifdef __WXMSW__
3740 #include <wx/msw/private.h> // to get wxGetWindowId
3741 #endif
3742
3743
3744 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3745 #ifdef __WXMSW__
3746 WXHWND hWnd = (WXHWND)_hWnd;
3747 long id = wxGetWindowId(hWnd);
3748 wxWindow* win = new wxWindow;
3749 if (parent)
3750 parent->AddChild(win);
3751 win->SetEventHandler(win);
3752 win->SetHWND(hWnd);
3753 win->SetId(id);
3754 win->SubclassWin(hWnd);
3755 win->AdoptAttributesFromHWND();
3756 win->SetupColours();
3757 return win;
3758 #else
3759 wxPyRaiseNotImplemented();
3760 return NULL;
3761 #endif
3762 }
3763
3764
3765 PyObject* GetTopLevelWindows() {
3766 return wxPy_ConvertList(&wxTopLevelWindows);
3767 }
3768
3769
3770 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3771 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3772 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3773
3774 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3775
3776
3777 SWIGINTERNINLINE int
3778 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3779 {
3780 unsigned long v;
3781 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3782 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3783 return res;
3784 }
3785
3786 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3787 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3788 wxMenuItemList& list = self->GetMenuItems();
3789 return wxPy_ConvertList(&list);
3790 }
3791 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3792 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3793 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3794 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3795 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3796 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3797 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3798 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3799 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3800 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3801 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3802 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3803 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3804 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3805 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3806 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3807 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3808 static const wxString wxPyControlNameStr(wxControlNameStr);
3809 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3810 if (clientData) {
3811 wxPyClientData* data = new wxPyClientData(clientData);
3812 return self->Append(item, data);
3813 } else
3814 return self->Append(item);
3815 }
3816 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
3817 if (clientData) {
3818 wxPyClientData* data = new wxPyClientData(clientData);
3819 return self->Insert(item, pos, data);
3820 } else
3821 return self->Insert(item, pos);
3822 }
3823 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
3824 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3825 if (data) {
3826 Py_INCREF(data->m_obj);
3827 return data->m_obj;
3828 } else {
3829 Py_INCREF(Py_None);
3830 return Py_None;
3831 }
3832 }
3833 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
3834 wxPyClientData* data = new wxPyClientData(clientData);
3835 self->SetClientObject(n, data);
3836 }
3837
3838
3839 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3840 wxPyUserData* data = NULL;
3841 if ( userData ) {
3842 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3843 data = new wxPyUserData(userData);
3844 wxPyEndBlockThreads(blocked);
3845 }
3846 return new wxSizerItem(window, proportion, flag, border, data);
3847 }
3848 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3849 wxPyUserData* data = NULL;
3850 if ( userData ) {
3851 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3852 data = new wxPyUserData(userData);
3853 wxPyEndBlockThreads(blocked);
3854 }
3855 return new wxSizerItem(width, height, proportion, flag, border, data);
3856 }
3857 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3858 wxPyUserData* data = NULL;
3859 if ( userData ) {
3860 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3861 data = new wxPyUserData(userData);
3862 wxPyEndBlockThreads(blocked);
3863 }
3864 return new wxSizerItem(sizer, proportion, flag, border, data);
3865 }
3866
3867 #include <float.h>
3868
3869
3870 SWIGINTERN int
3871 SWIG_AsVal_float (PyObject * obj, float *val)
3872 {
3873 double v;
3874 int res = SWIG_AsVal_double (obj, &v);
3875 if (SWIG_IsOK(res)) {
3876 if ((v < -FLT_MAX || v > FLT_MAX)) {
3877 return SWIG_OverflowError;
3878 } else {
3879 if (val) *val = static_cast< float >(v);
3880 }
3881 }
3882 return res;
3883 }
3884
3885
3886 SWIGINTERNINLINE PyObject *
3887 SWIG_From_float (float value)
3888 {
3889 return SWIG_From_double (value);
3890 }
3891
3892 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3893 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3894 if (data) {
3895 Py_INCREF(data->m_obj);
3896 return data->m_obj;
3897 } else {
3898 Py_INCREF(Py_None);
3899 return Py_None;
3900 }
3901 }
3902 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3903 wxPyUserData* data = NULL;
3904 if ( userData ) {
3905 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3906 data = new wxPyUserData(userData);
3907 wxPyEndBlockThreads(blocked);
3908 }
3909 self->SetUserData(data);
3910 }
3911
3912 // Figure out the type of the sizer item
3913
3914 struct wxPySizerItemInfo {
3915 wxPySizerItemInfo()
3916 : window(NULL), sizer(NULL), gotSize(false),
3917 size(wxDefaultSize), gotPos(false), pos(-1)
3918 {}
3919
3920 wxWindow* window;
3921 wxSizer* sizer;
3922 bool gotSize;
3923 wxSize size;
3924 bool gotPos;
3925 int pos;
3926 };
3927
3928 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
3929
3930 wxPySizerItemInfo info;
3931 wxSize size;
3932 wxSize* sizePtr = &size;
3933
3934 // Find out what the type of the item is
3935 // try wxWindow
3936 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
3937 PyErr_Clear();
3938 info.window = NULL;
3939
3940 // try wxSizer
3941 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
3942 PyErr_Clear();
3943 info.sizer = NULL;
3944
3945 // try wxSize or (w,h)
3946 if ( checkSize && wxSize_helper(item, &sizePtr)) {
3947 info.size = *sizePtr;
3948 info.gotSize = true;
3949 }
3950
3951 // or a single int
3952 if (checkIdx && PyInt_Check(item)) {
3953 info.pos = PyInt_AsLong(item);
3954 info.gotPos = true;
3955 }
3956 }
3957 }
3958
3959 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
3960 // no expected type, figure out what kind of error message to generate
3961 if ( !checkSize && !checkIdx )
3962 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
3963 else if ( checkSize && !checkIdx )
3964 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
3965 else if ( !checkSize && checkIdx)
3966 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
3967 else
3968 // can this one happen?
3969 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
3970 }
3971
3972 return info;
3973 }
3974
3975 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3976 if (!self->GetClientObject())
3977 self->SetClientObject(new wxPyOORClientData(_self));
3978 }
3979 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3980
3981 wxPyUserData* data = NULL;
3982 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3983 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3984 if ( userData && (info.window || info.sizer || info.gotSize) )
3985 data = new wxPyUserData(userData);
3986 if ( info.sizer )
3987 PyObject_SetAttrString(item,"thisown",Py_False);
3988 wxPyEndBlockThreads(blocked);
3989
3990 // Now call the real Add method if a valid item type was found
3991 if ( info.window )
3992 return self->Add(info.window, proportion, flag, border, data);
3993 else if ( info.sizer )
3994 return self->Add(info.sizer, proportion, flag, border, data);
3995 else if (info.gotSize)
3996 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3997 proportion, flag, border, data);
3998 else
3999 return NULL;
4000 }
4001 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4002
4003 wxPyUserData* data = NULL;
4004 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4005 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4006 if ( userData && (info.window || info.sizer || info.gotSize) )
4007 data = new wxPyUserData(userData);
4008 if ( info.sizer )
4009 PyObject_SetAttrString(item,"thisown",Py_False);
4010 wxPyEndBlockThreads(blocked);
4011
4012 // Now call the real Insert method if a valid item type was found
4013 if ( info.window )
4014 return self->Insert(before, info.window, proportion, flag, border, data);
4015 else if ( info.sizer )
4016 return self->Insert(before, info.sizer, proportion, flag, border, data);
4017 else if (info.gotSize)
4018 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4019 proportion, flag, border, data);
4020 else
4021 return NULL;
4022 }
4023 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4024
4025 wxPyUserData* data = NULL;
4026 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4027 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4028 if ( userData && (info.window || info.sizer || info.gotSize) )
4029 data = new wxPyUserData(userData);
4030 if ( info.sizer )
4031 PyObject_SetAttrString(item,"thisown",Py_False);
4032 wxPyEndBlockThreads(blocked);
4033
4034 // Now call the real Prepend method if a valid item type was found
4035 if ( info.window )
4036 return self->Prepend(info.window, proportion, flag, border, data);
4037 else if ( info.sizer )
4038 return self->Prepend(info.sizer, proportion, flag, border, data);
4039 else if (info.gotSize)
4040 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4041 proportion, flag, border, data);
4042 else
4043 return NULL;
4044 }
4045 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4047 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4048 wxPyEndBlockThreads(blocked);
4049 if ( info.window )
4050 return self->Remove(info.window);
4051 else if ( info.sizer )
4052 return self->Remove(info.sizer);
4053 else if ( info.gotPos )
4054 return self->Remove(info.pos);
4055 else
4056 return false;
4057 }
4058 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4059 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4060 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4061 wxPyEndBlockThreads(blocked);
4062 if ( info.window )
4063 return self->Detach(info.window);
4064 else if ( info.sizer )
4065 return self->Detach(info.sizer);
4066 else if ( info.gotPos )
4067 return self->Detach(info.pos);
4068 else
4069 return false;
4070 }
4071 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4072 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4073 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4074 wxPyEndBlockThreads(blocked);
4075 if ( info.window )
4076 return self->GetItem(info.window);
4077 else if ( info.sizer )
4078 return self->GetItem(info.sizer);
4079 else if ( info.gotPos )
4080 return self->GetItem(info.pos);
4081 else
4082 return NULL;
4083 }
4084 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4085 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4086 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4087 wxPyEndBlockThreads(blocked);
4088 if ( info.window )
4089 self->SetItemMinSize(info.window, size);
4090 else if ( info.sizer )
4091 self->SetItemMinSize(info.sizer, size);
4092 else if ( info.gotPos )
4093 self->SetItemMinSize(info.pos, size);
4094 }
4095 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4096 wxSizerItemList& list = self->GetChildren();
4097 return wxPy_ConvertList(&list);
4098 }
4099 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4100 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4101 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4102 wxPyEndBlockThreads(blocked);
4103 if ( info.window )
4104 return self->Show(info.window, show, recursive);
4105 else if ( info.sizer )
4106 return self->Show(info.sizer, show, recursive);
4107 else if ( info.gotPos )
4108 return self->Show(info.pos, show);
4109 else
4110 return false;
4111 }
4112 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4113 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4114 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4115 wxPyEndBlockThreads(blocked);
4116 if ( info.window )
4117 return self->IsShown(info.window);
4118 else if ( info.sizer )
4119 return self->IsShown(info.sizer);
4120 else if ( info.gotPos )
4121 return self->IsShown(info.pos);
4122 else
4123 return false;
4124 }
4125
4126 // See pyclasses.h
4127 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4128 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4129 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4130
4131
4132
4133
4134 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4135 {
4136 if (source == Py_None) {
4137 **obj = wxGBPosition(-1,-1);
4138 return true;
4139 }
4140 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4141 }
4142
4143 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4144 {
4145 if (source == Py_None) {
4146 **obj = wxGBSpan(-1,-1);
4147 return true;
4148 }
4149 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4150 }
4151
4152
4153 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4154 self->SetRow(row);
4155 self->SetCol(col);
4156 }
4157 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4158 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4159 PyObject* tup = PyTuple_New(2);
4160 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4161 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4162 wxPyEndBlockThreads(blocked);
4163 return tup;
4164 }
4165 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4166 self->SetRowspan(rowspan);
4167 self->SetColspan(colspan);
4168 }
4169 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4170 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4171 PyObject* tup = PyTuple_New(2);
4172 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4173 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4174 wxPyEndBlockThreads(blocked);
4175 return tup;
4176 }
4177 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4178 wxPyUserData* data = NULL;
4179 if ( userData ) {
4180 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4181 data = new wxPyUserData(userData);
4182 wxPyEndBlockThreads(blocked);
4183 }
4184 return new wxGBSizerItem(window, pos, span, flag, border, data);
4185 }
4186 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4187 wxPyUserData* data = NULL;
4188 if ( userData ) {
4189 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4190 data = new wxPyUserData(userData);
4191 wxPyEndBlockThreads(blocked);
4192 }
4193 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4194 }
4195 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4196 wxPyUserData* data = NULL;
4197 if ( userData ) {
4198 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4199 data = new wxPyUserData(userData);
4200 wxPyEndBlockThreads(blocked);
4201 }
4202 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4203 }
4204 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4205 int row, col;
4206 self->GetEndPos(row, col);
4207 return wxGBPosition(row, col);
4208 }
4209 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4210
4211 wxPyUserData* data = NULL;
4212 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4213 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4214 if ( userData && (info.window || info.sizer || info.gotSize) )
4215 data = new wxPyUserData(userData);
4216 if ( info.sizer )
4217 PyObject_SetAttrString(item,"thisown",Py_False);
4218 wxPyEndBlockThreads(blocked);
4219
4220 // Now call the real Add method if a valid item type was found
4221 if ( info.window )
4222 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4223 else if ( info.sizer )
4224 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4225 else if (info.gotSize)
4226 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4227 pos, span, flag, border, data);
4228 return NULL;
4229 }
4230
4231
4232 #ifdef __cplusplus
4233 extern "C" {
4234 #endif
4235 SWIGINTERN int EmptyString_set(PyObject *) {
4236 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4237 return 1;
4238 }
4239
4240
4241 SWIGINTERN PyObject *EmptyString_get(void) {
4242 PyObject *pyobj = 0;
4243
4244 {
4245 #if wxUSE_UNICODE
4246 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4247 #else
4248 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4249 #endif
4250 }
4251 return pyobj;
4252 }
4253
4254
4255 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4256 PyObject *resultobj = 0;
4257 wxObject *arg1 = (wxObject *) 0 ;
4258 wxString result;
4259 void *argp1 = 0 ;
4260 int res1 = 0 ;
4261 PyObject *swig_obj[1] ;
4262
4263 if (!args) SWIG_fail;
4264 swig_obj[0] = args;
4265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4266 if (!SWIG_IsOK(res1)) {
4267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4268 }
4269 arg1 = reinterpret_cast< wxObject * >(argp1);
4270 {
4271 PyThreadState* __tstate = wxPyBeginAllowThreads();
4272 result = wxObject_GetClassName(arg1);
4273 wxPyEndAllowThreads(__tstate);
4274 if (PyErr_Occurred()) SWIG_fail;
4275 }
4276 {
4277 #if wxUSE_UNICODE
4278 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4279 #else
4280 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4281 #endif
4282 }
4283 return resultobj;
4284 fail:
4285 return NULL;
4286 }
4287
4288
4289 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4290 PyObject *resultobj = 0;
4291 wxObject *arg1 = (wxObject *) 0 ;
4292 void *argp1 = 0 ;
4293 int res1 = 0 ;
4294 PyObject *swig_obj[1] ;
4295
4296 if (!args) SWIG_fail;
4297 swig_obj[0] = args;
4298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4299 if (!SWIG_IsOK(res1)) {
4300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4301 }
4302 arg1 = reinterpret_cast< wxObject * >(argp1);
4303 {
4304 PyThreadState* __tstate = wxPyBeginAllowThreads();
4305 wxObject_Destroy(arg1);
4306 wxPyEndAllowThreads(__tstate);
4307 if (PyErr_Occurred()) SWIG_fail;
4308 }
4309 resultobj = SWIG_Py_Void();
4310 return resultobj;
4311 fail:
4312 return NULL;
4313 }
4314
4315
4316 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4317 PyObject *obj;
4318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4319 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4320 return SWIG_Py_Void();
4321 }
4322
4323 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4324 PyObject *resultobj = 0;
4325 wxSize *arg1 = (wxSize *) 0 ;
4326 int arg2 ;
4327 void *argp1 = 0 ;
4328 int res1 = 0 ;
4329 int val2 ;
4330 int ecode2 = 0 ;
4331 PyObject *swig_obj[2] ;
4332
4333 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4335 if (!SWIG_IsOK(res1)) {
4336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4337 }
4338 arg1 = reinterpret_cast< wxSize * >(argp1);
4339 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4340 if (!SWIG_IsOK(ecode2)) {
4341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4342 }
4343 arg2 = static_cast< int >(val2);
4344 if (arg1) (arg1)->x = arg2;
4345
4346 resultobj = SWIG_Py_Void();
4347 return resultobj;
4348 fail:
4349 return NULL;
4350 }
4351
4352
4353 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4354 PyObject *resultobj = 0;
4355 wxSize *arg1 = (wxSize *) 0 ;
4356 int result;
4357 void *argp1 = 0 ;
4358 int res1 = 0 ;
4359 PyObject *swig_obj[1] ;
4360
4361 if (!args) SWIG_fail;
4362 swig_obj[0] = args;
4363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4364 if (!SWIG_IsOK(res1)) {
4365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4366 }
4367 arg1 = reinterpret_cast< wxSize * >(argp1);
4368 result = (int) ((arg1)->x);
4369 resultobj = SWIG_From_int(static_cast< int >(result));
4370 return resultobj;
4371 fail:
4372 return NULL;
4373 }
4374
4375
4376 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4377 PyObject *resultobj = 0;
4378 wxSize *arg1 = (wxSize *) 0 ;
4379 int arg2 ;
4380 void *argp1 = 0 ;
4381 int res1 = 0 ;
4382 int val2 ;
4383 int ecode2 = 0 ;
4384 PyObject *swig_obj[2] ;
4385
4386 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4388 if (!SWIG_IsOK(res1)) {
4389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4390 }
4391 arg1 = reinterpret_cast< wxSize * >(argp1);
4392 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4393 if (!SWIG_IsOK(ecode2)) {
4394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4395 }
4396 arg2 = static_cast< int >(val2);
4397 if (arg1) (arg1)->y = arg2;
4398
4399 resultobj = SWIG_Py_Void();
4400 return resultobj;
4401 fail:
4402 return NULL;
4403 }
4404
4405
4406 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4407 PyObject *resultobj = 0;
4408 wxSize *arg1 = (wxSize *) 0 ;
4409 int result;
4410 void *argp1 = 0 ;
4411 int res1 = 0 ;
4412 PyObject *swig_obj[1] ;
4413
4414 if (!args) SWIG_fail;
4415 swig_obj[0] = args;
4416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4417 if (!SWIG_IsOK(res1)) {
4418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4419 }
4420 arg1 = reinterpret_cast< wxSize * >(argp1);
4421 result = (int) ((arg1)->y);
4422 resultobj = SWIG_From_int(static_cast< int >(result));
4423 return resultobj;
4424 fail:
4425 return NULL;
4426 }
4427
4428
4429 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4430 PyObject *resultobj = 0;
4431 int arg1 = (int) 0 ;
4432 int arg2 = (int) 0 ;
4433 wxSize *result = 0 ;
4434 int val1 ;
4435 int ecode1 = 0 ;
4436 int val2 ;
4437 int ecode2 = 0 ;
4438 PyObject * obj0 = 0 ;
4439 PyObject * obj1 = 0 ;
4440 char * kwnames[] = {
4441 (char *) "w",(char *) "h", NULL
4442 };
4443
4444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4445 if (obj0) {
4446 ecode1 = SWIG_AsVal_int(obj0, &val1);
4447 if (!SWIG_IsOK(ecode1)) {
4448 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4449 }
4450 arg1 = static_cast< int >(val1);
4451 }
4452 if (obj1) {
4453 ecode2 = SWIG_AsVal_int(obj1, &val2);
4454 if (!SWIG_IsOK(ecode2)) {
4455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4456 }
4457 arg2 = static_cast< int >(val2);
4458 }
4459 {
4460 PyThreadState* __tstate = wxPyBeginAllowThreads();
4461 result = (wxSize *)new wxSize(arg1,arg2);
4462 wxPyEndAllowThreads(__tstate);
4463 if (PyErr_Occurred()) SWIG_fail;
4464 }
4465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4466 return resultobj;
4467 fail:
4468 return NULL;
4469 }
4470
4471
4472 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4473 PyObject *resultobj = 0;
4474 wxSize *arg1 = (wxSize *) 0 ;
4475 void *argp1 = 0 ;
4476 int res1 = 0 ;
4477 PyObject *swig_obj[1] ;
4478
4479 if (!args) SWIG_fail;
4480 swig_obj[0] = args;
4481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4482 if (!SWIG_IsOK(res1)) {
4483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4484 }
4485 arg1 = reinterpret_cast< wxSize * >(argp1);
4486 {
4487 PyThreadState* __tstate = wxPyBeginAllowThreads();
4488 delete arg1;
4489
4490 wxPyEndAllowThreads(__tstate);
4491 if (PyErr_Occurred()) SWIG_fail;
4492 }
4493 resultobj = SWIG_Py_Void();
4494 return resultobj;
4495 fail:
4496 return NULL;
4497 }
4498
4499
4500 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4501 PyObject *resultobj = 0;
4502 wxSize *arg1 = (wxSize *) 0 ;
4503 wxSize *arg2 = 0 ;
4504 bool result;
4505 void *argp1 = 0 ;
4506 int res1 = 0 ;
4507 wxSize temp2 ;
4508 PyObject * obj0 = 0 ;
4509 PyObject * obj1 = 0 ;
4510 char * kwnames[] = {
4511 (char *) "self",(char *) "sz", NULL
4512 };
4513
4514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4516 if (!SWIG_IsOK(res1)) {
4517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4518 }
4519 arg1 = reinterpret_cast< wxSize * >(argp1);
4520 {
4521 arg2 = &temp2;
4522 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4523 }
4524 {
4525 PyThreadState* __tstate = wxPyBeginAllowThreads();
4526 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
4527 wxPyEndAllowThreads(__tstate);
4528 if (PyErr_Occurred()) SWIG_fail;
4529 }
4530 {
4531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4532 }
4533 return resultobj;
4534 fail:
4535 return NULL;
4536 }
4537
4538
4539 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4540 PyObject *resultobj = 0;
4541 wxSize *arg1 = (wxSize *) 0 ;
4542 wxSize *arg2 = 0 ;
4543 bool result;
4544 void *argp1 = 0 ;
4545 int res1 = 0 ;
4546 wxSize temp2 ;
4547 PyObject * obj0 = 0 ;
4548 PyObject * obj1 = 0 ;
4549 char * kwnames[] = {
4550 (char *) "self",(char *) "sz", NULL
4551 };
4552
4553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4555 if (!SWIG_IsOK(res1)) {
4556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4557 }
4558 arg1 = reinterpret_cast< wxSize * >(argp1);
4559 {
4560 arg2 = &temp2;
4561 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4562 }
4563 {
4564 PyThreadState* __tstate = wxPyBeginAllowThreads();
4565 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
4566 wxPyEndAllowThreads(__tstate);
4567 if (PyErr_Occurred()) SWIG_fail;
4568 }
4569 {
4570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4571 }
4572 return resultobj;
4573 fail:
4574 return NULL;
4575 }
4576
4577
4578 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4579 PyObject *resultobj = 0;
4580 wxSize *arg1 = (wxSize *) 0 ;
4581 wxSize *arg2 = 0 ;
4582 wxSize result;
4583 void *argp1 = 0 ;
4584 int res1 = 0 ;
4585 wxSize temp2 ;
4586 PyObject * obj0 = 0 ;
4587 PyObject * obj1 = 0 ;
4588 char * kwnames[] = {
4589 (char *) "self",(char *) "sz", NULL
4590 };
4591
4592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4594 if (!SWIG_IsOK(res1)) {
4595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4596 }
4597 arg1 = reinterpret_cast< wxSize * >(argp1);
4598 {
4599 arg2 = &temp2;
4600 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4601 }
4602 {
4603 PyThreadState* __tstate = wxPyBeginAllowThreads();
4604 result = (arg1)->operator +((wxSize const &)*arg2);
4605 wxPyEndAllowThreads(__tstate);
4606 if (PyErr_Occurred()) SWIG_fail;
4607 }
4608 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4609 return resultobj;
4610 fail:
4611 return NULL;
4612 }
4613
4614
4615 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4616 PyObject *resultobj = 0;
4617 wxSize *arg1 = (wxSize *) 0 ;
4618 wxSize *arg2 = 0 ;
4619 wxSize result;
4620 void *argp1 = 0 ;
4621 int res1 = 0 ;
4622 wxSize temp2 ;
4623 PyObject * obj0 = 0 ;
4624 PyObject * obj1 = 0 ;
4625 char * kwnames[] = {
4626 (char *) "self",(char *) "sz", NULL
4627 };
4628
4629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4631 if (!SWIG_IsOK(res1)) {
4632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4633 }
4634 arg1 = reinterpret_cast< wxSize * >(argp1);
4635 {
4636 arg2 = &temp2;
4637 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4638 }
4639 {
4640 PyThreadState* __tstate = wxPyBeginAllowThreads();
4641 result = (arg1)->operator -((wxSize const &)*arg2);
4642 wxPyEndAllowThreads(__tstate);
4643 if (PyErr_Occurred()) SWIG_fail;
4644 }
4645 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4646 return resultobj;
4647 fail:
4648 return NULL;
4649 }
4650
4651
4652 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4653 PyObject *resultobj = 0;
4654 wxSize *arg1 = (wxSize *) 0 ;
4655 wxSize *arg2 = 0 ;
4656 void *argp1 = 0 ;
4657 int res1 = 0 ;
4658 wxSize temp2 ;
4659 PyObject * obj0 = 0 ;
4660 PyObject * obj1 = 0 ;
4661 char * kwnames[] = {
4662 (char *) "self",(char *) "sz", NULL
4663 };
4664
4665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4667 if (!SWIG_IsOK(res1)) {
4668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4669 }
4670 arg1 = reinterpret_cast< wxSize * >(argp1);
4671 {
4672 arg2 = &temp2;
4673 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4674 }
4675 {
4676 PyThreadState* __tstate = wxPyBeginAllowThreads();
4677 (arg1)->IncTo((wxSize const &)*arg2);
4678 wxPyEndAllowThreads(__tstate);
4679 if (PyErr_Occurred()) SWIG_fail;
4680 }
4681 resultobj = SWIG_Py_Void();
4682 return resultobj;
4683 fail:
4684 return NULL;
4685 }
4686
4687
4688 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4689 PyObject *resultobj = 0;
4690 wxSize *arg1 = (wxSize *) 0 ;
4691 wxSize *arg2 = 0 ;
4692 void *argp1 = 0 ;
4693 int res1 = 0 ;
4694 wxSize temp2 ;
4695 PyObject * obj0 = 0 ;
4696 PyObject * obj1 = 0 ;
4697 char * kwnames[] = {
4698 (char *) "self",(char *) "sz", NULL
4699 };
4700
4701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4703 if (!SWIG_IsOK(res1)) {
4704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4705 }
4706 arg1 = reinterpret_cast< wxSize * >(argp1);
4707 {
4708 arg2 = &temp2;
4709 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4710 }
4711 {
4712 PyThreadState* __tstate = wxPyBeginAllowThreads();
4713 (arg1)->DecTo((wxSize const &)*arg2);
4714 wxPyEndAllowThreads(__tstate);
4715 if (PyErr_Occurred()) SWIG_fail;
4716 }
4717 resultobj = SWIG_Py_Void();
4718 return resultobj;
4719 fail:
4720 return NULL;
4721 }
4722
4723
4724 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4725 PyObject *resultobj = 0;
4726 wxSize *arg1 = (wxSize *) 0 ;
4727 int arg2 ;
4728 int arg3 ;
4729 void *argp1 = 0 ;
4730 int res1 = 0 ;
4731 int val2 ;
4732 int ecode2 = 0 ;
4733 int val3 ;
4734 int ecode3 = 0 ;
4735 PyObject * obj0 = 0 ;
4736 PyObject * obj1 = 0 ;
4737 PyObject * obj2 = 0 ;
4738 char * kwnames[] = {
4739 (char *) "self",(char *) "w",(char *) "h", NULL
4740 };
4741
4742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4744 if (!SWIG_IsOK(res1)) {
4745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4746 }
4747 arg1 = reinterpret_cast< wxSize * >(argp1);
4748 ecode2 = SWIG_AsVal_int(obj1, &val2);
4749 if (!SWIG_IsOK(ecode2)) {
4750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4751 }
4752 arg2 = static_cast< int >(val2);
4753 ecode3 = SWIG_AsVal_int(obj2, &val3);
4754 if (!SWIG_IsOK(ecode3)) {
4755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4756 }
4757 arg3 = static_cast< int >(val3);
4758 {
4759 PyThreadState* __tstate = wxPyBeginAllowThreads();
4760 (arg1)->Set(arg2,arg3);
4761 wxPyEndAllowThreads(__tstate);
4762 if (PyErr_Occurred()) SWIG_fail;
4763 }
4764 resultobj = SWIG_Py_Void();
4765 return resultobj;
4766 fail:
4767 return NULL;
4768 }
4769
4770
4771 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4772 PyObject *resultobj = 0;
4773 wxSize *arg1 = (wxSize *) 0 ;
4774 int arg2 ;
4775 void *argp1 = 0 ;
4776 int res1 = 0 ;
4777 int val2 ;
4778 int ecode2 = 0 ;
4779 PyObject * obj0 = 0 ;
4780 PyObject * obj1 = 0 ;
4781 char * kwnames[] = {
4782 (char *) "self",(char *) "w", NULL
4783 };
4784
4785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4787 if (!SWIG_IsOK(res1)) {
4788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4789 }
4790 arg1 = reinterpret_cast< wxSize * >(argp1);
4791 ecode2 = SWIG_AsVal_int(obj1, &val2);
4792 if (!SWIG_IsOK(ecode2)) {
4793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4794 }
4795 arg2 = static_cast< int >(val2);
4796 {
4797 PyThreadState* __tstate = wxPyBeginAllowThreads();
4798 (arg1)->SetWidth(arg2);
4799 wxPyEndAllowThreads(__tstate);
4800 if (PyErr_Occurred()) SWIG_fail;
4801 }
4802 resultobj = SWIG_Py_Void();
4803 return resultobj;
4804 fail:
4805 return NULL;
4806 }
4807
4808
4809 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4810 PyObject *resultobj = 0;
4811 wxSize *arg1 = (wxSize *) 0 ;
4812 int arg2 ;
4813 void *argp1 = 0 ;
4814 int res1 = 0 ;
4815 int val2 ;
4816 int ecode2 = 0 ;
4817 PyObject * obj0 = 0 ;
4818 PyObject * obj1 = 0 ;
4819 char * kwnames[] = {
4820 (char *) "self",(char *) "h", NULL
4821 };
4822
4823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4825 if (!SWIG_IsOK(res1)) {
4826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4827 }
4828 arg1 = reinterpret_cast< wxSize * >(argp1);
4829 ecode2 = SWIG_AsVal_int(obj1, &val2);
4830 if (!SWIG_IsOK(ecode2)) {
4831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4832 }
4833 arg2 = static_cast< int >(val2);
4834 {
4835 PyThreadState* __tstate = wxPyBeginAllowThreads();
4836 (arg1)->SetHeight(arg2);
4837 wxPyEndAllowThreads(__tstate);
4838 if (PyErr_Occurred()) SWIG_fail;
4839 }
4840 resultobj = SWIG_Py_Void();
4841 return resultobj;
4842 fail:
4843 return NULL;
4844 }
4845
4846
4847 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4848 PyObject *resultobj = 0;
4849 wxSize *arg1 = (wxSize *) 0 ;
4850 int result;
4851 void *argp1 = 0 ;
4852 int res1 = 0 ;
4853 PyObject *swig_obj[1] ;
4854
4855 if (!args) SWIG_fail;
4856 swig_obj[0] = args;
4857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4858 if (!SWIG_IsOK(res1)) {
4859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4860 }
4861 arg1 = reinterpret_cast< wxSize * >(argp1);
4862 {
4863 PyThreadState* __tstate = wxPyBeginAllowThreads();
4864 result = (int)((wxSize const *)arg1)->GetWidth();
4865 wxPyEndAllowThreads(__tstate);
4866 if (PyErr_Occurred()) SWIG_fail;
4867 }
4868 resultobj = SWIG_From_int(static_cast< int >(result));
4869 return resultobj;
4870 fail:
4871 return NULL;
4872 }
4873
4874
4875 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4876 PyObject *resultobj = 0;
4877 wxSize *arg1 = (wxSize *) 0 ;
4878 int result;
4879 void *argp1 = 0 ;
4880 int res1 = 0 ;
4881 PyObject *swig_obj[1] ;
4882
4883 if (!args) SWIG_fail;
4884 swig_obj[0] = args;
4885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4886 if (!SWIG_IsOK(res1)) {
4887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
4888 }
4889 arg1 = reinterpret_cast< wxSize * >(argp1);
4890 {
4891 PyThreadState* __tstate = wxPyBeginAllowThreads();
4892 result = (int)((wxSize const *)arg1)->GetHeight();
4893 wxPyEndAllowThreads(__tstate);
4894 if (PyErr_Occurred()) SWIG_fail;
4895 }
4896 resultobj = SWIG_From_int(static_cast< int >(result));
4897 return resultobj;
4898 fail:
4899 return NULL;
4900 }
4901
4902
4903 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4904 PyObject *resultobj = 0;
4905 wxSize *arg1 = (wxSize *) 0 ;
4906 bool result;
4907 void *argp1 = 0 ;
4908 int res1 = 0 ;
4909 PyObject *swig_obj[1] ;
4910
4911 if (!args) SWIG_fail;
4912 swig_obj[0] = args;
4913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4914 if (!SWIG_IsOK(res1)) {
4915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
4916 }
4917 arg1 = reinterpret_cast< wxSize * >(argp1);
4918 {
4919 PyThreadState* __tstate = wxPyBeginAllowThreads();
4920 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
4921 wxPyEndAllowThreads(__tstate);
4922 if (PyErr_Occurred()) SWIG_fail;
4923 }
4924 {
4925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4926 }
4927 return resultobj;
4928 fail:
4929 return NULL;
4930 }
4931
4932
4933 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4934 PyObject *resultobj = 0;
4935 wxSize *arg1 = (wxSize *) 0 ;
4936 wxSize *arg2 = 0 ;
4937 void *argp1 = 0 ;
4938 int res1 = 0 ;
4939 wxSize temp2 ;
4940 PyObject * obj0 = 0 ;
4941 PyObject * obj1 = 0 ;
4942 char * kwnames[] = {
4943 (char *) "self",(char *) "size", NULL
4944 };
4945
4946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
4947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4948 if (!SWIG_IsOK(res1)) {
4949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
4950 }
4951 arg1 = reinterpret_cast< wxSize * >(argp1);
4952 {
4953 arg2 = &temp2;
4954 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4955 }
4956 {
4957 PyThreadState* __tstate = wxPyBeginAllowThreads();
4958 (arg1)->SetDefaults((wxSize const &)*arg2);
4959 wxPyEndAllowThreads(__tstate);
4960 if (PyErr_Occurred()) SWIG_fail;
4961 }
4962 resultobj = SWIG_Py_Void();
4963 return resultobj;
4964 fail:
4965 return NULL;
4966 }
4967
4968
4969 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4970 PyObject *resultobj = 0;
4971 wxSize *arg1 = (wxSize *) 0 ;
4972 PyObject *result = 0 ;
4973 void *argp1 = 0 ;
4974 int res1 = 0 ;
4975 PyObject *swig_obj[1] ;
4976
4977 if (!args) SWIG_fail;
4978 swig_obj[0] = args;
4979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4980 if (!SWIG_IsOK(res1)) {
4981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
4982 }
4983 arg1 = reinterpret_cast< wxSize * >(argp1);
4984 {
4985 PyThreadState* __tstate = wxPyBeginAllowThreads();
4986 result = (PyObject *)wxSize_Get(arg1);
4987 wxPyEndAllowThreads(__tstate);
4988 if (PyErr_Occurred()) SWIG_fail;
4989 }
4990 resultobj = result;
4991 return resultobj;
4992 fail:
4993 return NULL;
4994 }
4995
4996
4997 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4998 PyObject *obj;
4999 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5000 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5001 return SWIG_Py_Void();
5002 }
5003
5004 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5005 return SWIG_Python_InitShadowInstance(args);
5006 }
5007
5008 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5009 PyObject *resultobj = 0;
5010 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5011 double arg2 ;
5012 void *argp1 = 0 ;
5013 int res1 = 0 ;
5014 double val2 ;
5015 int ecode2 = 0 ;
5016 PyObject *swig_obj[2] ;
5017
5018 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5020 if (!SWIG_IsOK(res1)) {
5021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5022 }
5023 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5024 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5025 if (!SWIG_IsOK(ecode2)) {
5026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5027 }
5028 arg2 = static_cast< double >(val2);
5029 if (arg1) (arg1)->x = arg2;
5030
5031 resultobj = SWIG_Py_Void();
5032 return resultobj;
5033 fail:
5034 return NULL;
5035 }
5036
5037
5038 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5039 PyObject *resultobj = 0;
5040 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5041 double result;
5042 void *argp1 = 0 ;
5043 int res1 = 0 ;
5044 PyObject *swig_obj[1] ;
5045
5046 if (!args) SWIG_fail;
5047 swig_obj[0] = args;
5048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5049 if (!SWIG_IsOK(res1)) {
5050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5051 }
5052 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5053 result = (double) ((arg1)->x);
5054 resultobj = SWIG_From_double(static_cast< double >(result));
5055 return resultobj;
5056 fail:
5057 return NULL;
5058 }
5059
5060
5061 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5062 PyObject *resultobj = 0;
5063 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5064 double arg2 ;
5065 void *argp1 = 0 ;
5066 int res1 = 0 ;
5067 double val2 ;
5068 int ecode2 = 0 ;
5069 PyObject *swig_obj[2] ;
5070
5071 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5073 if (!SWIG_IsOK(res1)) {
5074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5075 }
5076 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5077 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5078 if (!SWIG_IsOK(ecode2)) {
5079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5080 }
5081 arg2 = static_cast< double >(val2);
5082 if (arg1) (arg1)->y = arg2;
5083
5084 resultobj = SWIG_Py_Void();
5085 return resultobj;
5086 fail:
5087 return NULL;
5088 }
5089
5090
5091 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5092 PyObject *resultobj = 0;
5093 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5094 double result;
5095 void *argp1 = 0 ;
5096 int res1 = 0 ;
5097 PyObject *swig_obj[1] ;
5098
5099 if (!args) SWIG_fail;
5100 swig_obj[0] = args;
5101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5102 if (!SWIG_IsOK(res1)) {
5103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5104 }
5105 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5106 result = (double) ((arg1)->y);
5107 resultobj = SWIG_From_double(static_cast< double >(result));
5108 return resultobj;
5109 fail:
5110 return NULL;
5111 }
5112
5113
5114 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5115 PyObject *resultobj = 0;
5116 double arg1 = (double) 0.0 ;
5117 double arg2 = (double) 0.0 ;
5118 wxRealPoint *result = 0 ;
5119 double val1 ;
5120 int ecode1 = 0 ;
5121 double val2 ;
5122 int ecode2 = 0 ;
5123 PyObject * obj0 = 0 ;
5124 PyObject * obj1 = 0 ;
5125 char * kwnames[] = {
5126 (char *) "x",(char *) "y", NULL
5127 };
5128
5129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5130 if (obj0) {
5131 ecode1 = SWIG_AsVal_double(obj0, &val1);
5132 if (!SWIG_IsOK(ecode1)) {
5133 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5134 }
5135 arg1 = static_cast< double >(val1);
5136 }
5137 if (obj1) {
5138 ecode2 = SWIG_AsVal_double(obj1, &val2);
5139 if (!SWIG_IsOK(ecode2)) {
5140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5141 }
5142 arg2 = static_cast< double >(val2);
5143 }
5144 {
5145 PyThreadState* __tstate = wxPyBeginAllowThreads();
5146 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5147 wxPyEndAllowThreads(__tstate);
5148 if (PyErr_Occurred()) SWIG_fail;
5149 }
5150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5151 return resultobj;
5152 fail:
5153 return NULL;
5154 }
5155
5156
5157 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5158 PyObject *resultobj = 0;
5159 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5160 void *argp1 = 0 ;
5161 int res1 = 0 ;
5162 PyObject *swig_obj[1] ;
5163
5164 if (!args) SWIG_fail;
5165 swig_obj[0] = args;
5166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5167 if (!SWIG_IsOK(res1)) {
5168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5169 }
5170 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5171 {
5172 PyThreadState* __tstate = wxPyBeginAllowThreads();
5173 delete arg1;
5174
5175 wxPyEndAllowThreads(__tstate);
5176 if (PyErr_Occurred()) SWIG_fail;
5177 }
5178 resultobj = SWIG_Py_Void();
5179 return resultobj;
5180 fail:
5181 return NULL;
5182 }
5183
5184
5185 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5186 PyObject *resultobj = 0;
5187 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5188 wxRealPoint *arg2 = 0 ;
5189 bool result;
5190 void *argp1 = 0 ;
5191 int res1 = 0 ;
5192 wxRealPoint temp2 ;
5193 PyObject * obj0 = 0 ;
5194 PyObject * obj1 = 0 ;
5195 char * kwnames[] = {
5196 (char *) "self",(char *) "pt", NULL
5197 };
5198
5199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5201 if (!SWIG_IsOK(res1)) {
5202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5203 }
5204 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5205 {
5206 arg2 = &temp2;
5207 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5208 }
5209 {
5210 PyThreadState* __tstate = wxPyBeginAllowThreads();
5211 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
5212 wxPyEndAllowThreads(__tstate);
5213 if (PyErr_Occurred()) SWIG_fail;
5214 }
5215 {
5216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5217 }
5218 return resultobj;
5219 fail:
5220 return NULL;
5221 }
5222
5223
5224 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5225 PyObject *resultobj = 0;
5226 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5227 wxRealPoint *arg2 = 0 ;
5228 bool result;
5229 void *argp1 = 0 ;
5230 int res1 = 0 ;
5231 wxRealPoint temp2 ;
5232 PyObject * obj0 = 0 ;
5233 PyObject * obj1 = 0 ;
5234 char * kwnames[] = {
5235 (char *) "self",(char *) "pt", NULL
5236 };
5237
5238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5240 if (!SWIG_IsOK(res1)) {
5241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5242 }
5243 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5244 {
5245 arg2 = &temp2;
5246 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5247 }
5248 {
5249 PyThreadState* __tstate = wxPyBeginAllowThreads();
5250 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
5251 wxPyEndAllowThreads(__tstate);
5252 if (PyErr_Occurred()) SWIG_fail;
5253 }
5254 {
5255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5256 }
5257 return resultobj;
5258 fail:
5259 return NULL;
5260 }
5261
5262
5263 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5264 PyObject *resultobj = 0;
5265 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5266 wxRealPoint *arg2 = 0 ;
5267 wxRealPoint result;
5268 void *argp1 = 0 ;
5269 int res1 = 0 ;
5270 wxRealPoint temp2 ;
5271 PyObject * obj0 = 0 ;
5272 PyObject * obj1 = 0 ;
5273 char * kwnames[] = {
5274 (char *) "self",(char *) "pt", NULL
5275 };
5276
5277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5279 if (!SWIG_IsOK(res1)) {
5280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5281 }
5282 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5283 {
5284 arg2 = &temp2;
5285 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5286 }
5287 {
5288 PyThreadState* __tstate = wxPyBeginAllowThreads();
5289 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5290 wxPyEndAllowThreads(__tstate);
5291 if (PyErr_Occurred()) SWIG_fail;
5292 }
5293 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5294 return resultobj;
5295 fail:
5296 return NULL;
5297 }
5298
5299
5300 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5301 PyObject *resultobj = 0;
5302 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5303 wxRealPoint *arg2 = 0 ;
5304 wxRealPoint result;
5305 void *argp1 = 0 ;
5306 int res1 = 0 ;
5307 wxRealPoint temp2 ;
5308 PyObject * obj0 = 0 ;
5309 PyObject * obj1 = 0 ;
5310 char * kwnames[] = {
5311 (char *) "self",(char *) "pt", NULL
5312 };
5313
5314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5316 if (!SWIG_IsOK(res1)) {
5317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5318 }
5319 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5320 {
5321 arg2 = &temp2;
5322 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5323 }
5324 {
5325 PyThreadState* __tstate = wxPyBeginAllowThreads();
5326 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5327 wxPyEndAllowThreads(__tstate);
5328 if (PyErr_Occurred()) SWIG_fail;
5329 }
5330 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5331 return resultobj;
5332 fail:
5333 return NULL;
5334 }
5335
5336
5337 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5338 PyObject *resultobj = 0;
5339 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5340 double arg2 ;
5341 double arg3 ;
5342 void *argp1 = 0 ;
5343 int res1 = 0 ;
5344 double val2 ;
5345 int ecode2 = 0 ;
5346 double val3 ;
5347 int ecode3 = 0 ;
5348 PyObject * obj0 = 0 ;
5349 PyObject * obj1 = 0 ;
5350 PyObject * obj2 = 0 ;
5351 char * kwnames[] = {
5352 (char *) "self",(char *) "x",(char *) "y", NULL
5353 };
5354
5355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5357 if (!SWIG_IsOK(res1)) {
5358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5359 }
5360 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5361 ecode2 = SWIG_AsVal_double(obj1, &val2);
5362 if (!SWIG_IsOK(ecode2)) {
5363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5364 }
5365 arg2 = static_cast< double >(val2);
5366 ecode3 = SWIG_AsVal_double(obj2, &val3);
5367 if (!SWIG_IsOK(ecode3)) {
5368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5369 }
5370 arg3 = static_cast< double >(val3);
5371 {
5372 PyThreadState* __tstate = wxPyBeginAllowThreads();
5373 wxRealPoint_Set(arg1,arg2,arg3);
5374 wxPyEndAllowThreads(__tstate);
5375 if (PyErr_Occurred()) SWIG_fail;
5376 }
5377 resultobj = SWIG_Py_Void();
5378 return resultobj;
5379 fail:
5380 return NULL;
5381 }
5382
5383
5384 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5385 PyObject *resultobj = 0;
5386 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5387 PyObject *result = 0 ;
5388 void *argp1 = 0 ;
5389 int res1 = 0 ;
5390 PyObject *swig_obj[1] ;
5391
5392 if (!args) SWIG_fail;
5393 swig_obj[0] = args;
5394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5395 if (!SWIG_IsOK(res1)) {
5396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5397 }
5398 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5399 {
5400 PyThreadState* __tstate = wxPyBeginAllowThreads();
5401 result = (PyObject *)wxRealPoint_Get(arg1);
5402 wxPyEndAllowThreads(__tstate);
5403 if (PyErr_Occurred()) SWIG_fail;
5404 }
5405 resultobj = result;
5406 return resultobj;
5407 fail:
5408 return NULL;
5409 }
5410
5411
5412 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5413 PyObject *obj;
5414 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5415 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5416 return SWIG_Py_Void();
5417 }
5418
5419 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5420 return SWIG_Python_InitShadowInstance(args);
5421 }
5422
5423 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5424 PyObject *resultobj = 0;
5425 wxPoint *arg1 = (wxPoint *) 0 ;
5426 int arg2 ;
5427 void *argp1 = 0 ;
5428 int res1 = 0 ;
5429 int val2 ;
5430 int ecode2 = 0 ;
5431 PyObject *swig_obj[2] ;
5432
5433 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5435 if (!SWIG_IsOK(res1)) {
5436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5437 }
5438 arg1 = reinterpret_cast< wxPoint * >(argp1);
5439 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5440 if (!SWIG_IsOK(ecode2)) {
5441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5442 }
5443 arg2 = static_cast< int >(val2);
5444 if (arg1) (arg1)->x = arg2;
5445
5446 resultobj = SWIG_Py_Void();
5447 return resultobj;
5448 fail:
5449 return NULL;
5450 }
5451
5452
5453 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5454 PyObject *resultobj = 0;
5455 wxPoint *arg1 = (wxPoint *) 0 ;
5456 int result;
5457 void *argp1 = 0 ;
5458 int res1 = 0 ;
5459 PyObject *swig_obj[1] ;
5460
5461 if (!args) SWIG_fail;
5462 swig_obj[0] = args;
5463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5464 if (!SWIG_IsOK(res1)) {
5465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5466 }
5467 arg1 = reinterpret_cast< wxPoint * >(argp1);
5468 result = (int) ((arg1)->x);
5469 resultobj = SWIG_From_int(static_cast< int >(result));
5470 return resultobj;
5471 fail:
5472 return NULL;
5473 }
5474
5475
5476 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5477 PyObject *resultobj = 0;
5478 wxPoint *arg1 = (wxPoint *) 0 ;
5479 int arg2 ;
5480 void *argp1 = 0 ;
5481 int res1 = 0 ;
5482 int val2 ;
5483 int ecode2 = 0 ;
5484 PyObject *swig_obj[2] ;
5485
5486 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5488 if (!SWIG_IsOK(res1)) {
5489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5490 }
5491 arg1 = reinterpret_cast< wxPoint * >(argp1);
5492 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5493 if (!SWIG_IsOK(ecode2)) {
5494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5495 }
5496 arg2 = static_cast< int >(val2);
5497 if (arg1) (arg1)->y = arg2;
5498
5499 resultobj = SWIG_Py_Void();
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5507 PyObject *resultobj = 0;
5508 wxPoint *arg1 = (wxPoint *) 0 ;
5509 int result;
5510 void *argp1 = 0 ;
5511 int res1 = 0 ;
5512 PyObject *swig_obj[1] ;
5513
5514 if (!args) SWIG_fail;
5515 swig_obj[0] = args;
5516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5517 if (!SWIG_IsOK(res1)) {
5518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5519 }
5520 arg1 = reinterpret_cast< wxPoint * >(argp1);
5521 result = (int) ((arg1)->y);
5522 resultobj = SWIG_From_int(static_cast< int >(result));
5523 return resultobj;
5524 fail:
5525 return NULL;
5526 }
5527
5528
5529 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5530 PyObject *resultobj = 0;
5531 int arg1 = (int) 0 ;
5532 int arg2 = (int) 0 ;
5533 wxPoint *result = 0 ;
5534 int val1 ;
5535 int ecode1 = 0 ;
5536 int val2 ;
5537 int ecode2 = 0 ;
5538 PyObject * obj0 = 0 ;
5539 PyObject * obj1 = 0 ;
5540 char * kwnames[] = {
5541 (char *) "x",(char *) "y", NULL
5542 };
5543
5544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5545 if (obj0) {
5546 ecode1 = SWIG_AsVal_int(obj0, &val1);
5547 if (!SWIG_IsOK(ecode1)) {
5548 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5549 }
5550 arg1 = static_cast< int >(val1);
5551 }
5552 if (obj1) {
5553 ecode2 = SWIG_AsVal_int(obj1, &val2);
5554 if (!SWIG_IsOK(ecode2)) {
5555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5556 }
5557 arg2 = static_cast< int >(val2);
5558 }
5559 {
5560 PyThreadState* __tstate = wxPyBeginAllowThreads();
5561 result = (wxPoint *)new wxPoint(arg1,arg2);
5562 wxPyEndAllowThreads(__tstate);
5563 if (PyErr_Occurred()) SWIG_fail;
5564 }
5565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5566 return resultobj;
5567 fail:
5568 return NULL;
5569 }
5570
5571
5572 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5573 PyObject *resultobj = 0;
5574 wxPoint *arg1 = (wxPoint *) 0 ;
5575 void *argp1 = 0 ;
5576 int res1 = 0 ;
5577 PyObject *swig_obj[1] ;
5578
5579 if (!args) SWIG_fail;
5580 swig_obj[0] = args;
5581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5582 if (!SWIG_IsOK(res1)) {
5583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5584 }
5585 arg1 = reinterpret_cast< wxPoint * >(argp1);
5586 {
5587 PyThreadState* __tstate = wxPyBeginAllowThreads();
5588 delete arg1;
5589
5590 wxPyEndAllowThreads(__tstate);
5591 if (PyErr_Occurred()) SWIG_fail;
5592 }
5593 resultobj = SWIG_Py_Void();
5594 return resultobj;
5595 fail:
5596 return NULL;
5597 }
5598
5599
5600 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5601 PyObject *resultobj = 0;
5602 wxPoint *arg1 = (wxPoint *) 0 ;
5603 wxPoint *arg2 = 0 ;
5604 bool result;
5605 void *argp1 = 0 ;
5606 int res1 = 0 ;
5607 wxPoint temp2 ;
5608 PyObject * obj0 = 0 ;
5609 PyObject * obj1 = 0 ;
5610 char * kwnames[] = {
5611 (char *) "self",(char *) "pt", NULL
5612 };
5613
5614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5616 if (!SWIG_IsOK(res1)) {
5617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5618 }
5619 arg1 = reinterpret_cast< wxPoint * >(argp1);
5620 {
5621 arg2 = &temp2;
5622 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5623 }
5624 {
5625 PyThreadState* __tstate = wxPyBeginAllowThreads();
5626 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
5627 wxPyEndAllowThreads(__tstate);
5628 if (PyErr_Occurred()) SWIG_fail;
5629 }
5630 {
5631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5632 }
5633 return resultobj;
5634 fail:
5635 return NULL;
5636 }
5637
5638
5639 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5640 PyObject *resultobj = 0;
5641 wxPoint *arg1 = (wxPoint *) 0 ;
5642 wxPoint *arg2 = 0 ;
5643 bool result;
5644 void *argp1 = 0 ;
5645 int res1 = 0 ;
5646 wxPoint temp2 ;
5647 PyObject * obj0 = 0 ;
5648 PyObject * obj1 = 0 ;
5649 char * kwnames[] = {
5650 (char *) "self",(char *) "pt", NULL
5651 };
5652
5653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5655 if (!SWIG_IsOK(res1)) {
5656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5657 }
5658 arg1 = reinterpret_cast< wxPoint * >(argp1);
5659 {
5660 arg2 = &temp2;
5661 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5662 }
5663 {
5664 PyThreadState* __tstate = wxPyBeginAllowThreads();
5665 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
5666 wxPyEndAllowThreads(__tstate);
5667 if (PyErr_Occurred()) SWIG_fail;
5668 }
5669 {
5670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5671 }
5672 return resultobj;
5673 fail:
5674 return NULL;
5675 }
5676
5677
5678 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5679 PyObject *resultobj = 0;
5680 wxPoint *arg1 = (wxPoint *) 0 ;
5681 wxPoint *arg2 = 0 ;
5682 wxPoint result;
5683 void *argp1 = 0 ;
5684 int res1 = 0 ;
5685 wxPoint temp2 ;
5686 PyObject * obj0 = 0 ;
5687 PyObject * obj1 = 0 ;
5688 char * kwnames[] = {
5689 (char *) "self",(char *) "pt", NULL
5690 };
5691
5692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5694 if (!SWIG_IsOK(res1)) {
5695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5696 }
5697 arg1 = reinterpret_cast< wxPoint * >(argp1);
5698 {
5699 arg2 = &temp2;
5700 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5701 }
5702 {
5703 PyThreadState* __tstate = wxPyBeginAllowThreads();
5704 result = (arg1)->operator +((wxPoint const &)*arg2);
5705 wxPyEndAllowThreads(__tstate);
5706 if (PyErr_Occurred()) SWIG_fail;
5707 }
5708 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5709 return resultobj;
5710 fail:
5711 return NULL;
5712 }
5713
5714
5715 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5716 PyObject *resultobj = 0;
5717 wxPoint *arg1 = (wxPoint *) 0 ;
5718 wxPoint *arg2 = 0 ;
5719 wxPoint result;
5720 void *argp1 = 0 ;
5721 int res1 = 0 ;
5722 wxPoint temp2 ;
5723 PyObject * obj0 = 0 ;
5724 PyObject * obj1 = 0 ;
5725 char * kwnames[] = {
5726 (char *) "self",(char *) "pt", NULL
5727 };
5728
5729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5731 if (!SWIG_IsOK(res1)) {
5732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5733 }
5734 arg1 = reinterpret_cast< wxPoint * >(argp1);
5735 {
5736 arg2 = &temp2;
5737 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5738 }
5739 {
5740 PyThreadState* __tstate = wxPyBeginAllowThreads();
5741 result = (arg1)->operator -((wxPoint const &)*arg2);
5742 wxPyEndAllowThreads(__tstate);
5743 if (PyErr_Occurred()) SWIG_fail;
5744 }
5745 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5746 return resultobj;
5747 fail:
5748 return NULL;
5749 }
5750
5751
5752 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5753 PyObject *resultobj = 0;
5754 wxPoint *arg1 = (wxPoint *) 0 ;
5755 wxPoint *arg2 = 0 ;
5756 wxPoint *result = 0 ;
5757 void *argp1 = 0 ;
5758 int res1 = 0 ;
5759 wxPoint temp2 ;
5760 PyObject * obj0 = 0 ;
5761 PyObject * obj1 = 0 ;
5762 char * kwnames[] = {
5763 (char *) "self",(char *) "pt", NULL
5764 };
5765
5766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5768 if (!SWIG_IsOK(res1)) {
5769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5770 }
5771 arg1 = reinterpret_cast< wxPoint * >(argp1);
5772 {
5773 arg2 = &temp2;
5774 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5775 }
5776 {
5777 PyThreadState* __tstate = wxPyBeginAllowThreads();
5778 {
5779 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5780 result = (wxPoint *) &_result_ref;
5781 }
5782 wxPyEndAllowThreads(__tstate);
5783 if (PyErr_Occurred()) SWIG_fail;
5784 }
5785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5786 return resultobj;
5787 fail:
5788 return NULL;
5789 }
5790
5791
5792 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5793 PyObject *resultobj = 0;
5794 wxPoint *arg1 = (wxPoint *) 0 ;
5795 wxPoint *arg2 = 0 ;
5796 wxPoint *result = 0 ;
5797 void *argp1 = 0 ;
5798 int res1 = 0 ;
5799 wxPoint temp2 ;
5800 PyObject * obj0 = 0 ;
5801 PyObject * obj1 = 0 ;
5802 char * kwnames[] = {
5803 (char *) "self",(char *) "pt", NULL
5804 };
5805
5806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5808 if (!SWIG_IsOK(res1)) {
5809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5810 }
5811 arg1 = reinterpret_cast< wxPoint * >(argp1);
5812 {
5813 arg2 = &temp2;
5814 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5815 }
5816 {
5817 PyThreadState* __tstate = wxPyBeginAllowThreads();
5818 {
5819 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5820 result = (wxPoint *) &_result_ref;
5821 }
5822 wxPyEndAllowThreads(__tstate);
5823 if (PyErr_Occurred()) SWIG_fail;
5824 }
5825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5826 return resultobj;
5827 fail:
5828 return NULL;
5829 }
5830
5831
5832 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5833 PyObject *resultobj = 0;
5834 wxPoint *arg1 = (wxPoint *) 0 ;
5835 long arg2 ;
5836 long arg3 ;
5837 void *argp1 = 0 ;
5838 int res1 = 0 ;
5839 long val2 ;
5840 int ecode2 = 0 ;
5841 long val3 ;
5842 int ecode3 = 0 ;
5843 PyObject * obj0 = 0 ;
5844 PyObject * obj1 = 0 ;
5845 PyObject * obj2 = 0 ;
5846 char * kwnames[] = {
5847 (char *) "self",(char *) "x",(char *) "y", NULL
5848 };
5849
5850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5852 if (!SWIG_IsOK(res1)) {
5853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5854 }
5855 arg1 = reinterpret_cast< wxPoint * >(argp1);
5856 ecode2 = SWIG_AsVal_long(obj1, &val2);
5857 if (!SWIG_IsOK(ecode2)) {
5858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5859 }
5860 arg2 = static_cast< long >(val2);
5861 ecode3 = SWIG_AsVal_long(obj2, &val3);
5862 if (!SWIG_IsOK(ecode3)) {
5863 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5864 }
5865 arg3 = static_cast< long >(val3);
5866 {
5867 PyThreadState* __tstate = wxPyBeginAllowThreads();
5868 wxPoint_Set(arg1,arg2,arg3);
5869 wxPyEndAllowThreads(__tstate);
5870 if (PyErr_Occurred()) SWIG_fail;
5871 }
5872 resultobj = SWIG_Py_Void();
5873 return resultobj;
5874 fail:
5875 return NULL;
5876 }
5877
5878
5879 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5880 PyObject *resultobj = 0;
5881 wxPoint *arg1 = (wxPoint *) 0 ;
5882 PyObject *result = 0 ;
5883 void *argp1 = 0 ;
5884 int res1 = 0 ;
5885 PyObject *swig_obj[1] ;
5886
5887 if (!args) SWIG_fail;
5888 swig_obj[0] = args;
5889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5890 if (!SWIG_IsOK(res1)) {
5891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5892 }
5893 arg1 = reinterpret_cast< wxPoint * >(argp1);
5894 {
5895 PyThreadState* __tstate = wxPyBeginAllowThreads();
5896 result = (PyObject *)wxPoint_Get(arg1);
5897 wxPyEndAllowThreads(__tstate);
5898 if (PyErr_Occurred()) SWIG_fail;
5899 }
5900 resultobj = result;
5901 return resultobj;
5902 fail:
5903 return NULL;
5904 }
5905
5906
5907 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5908 PyObject *obj;
5909 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5910 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
5911 return SWIG_Py_Void();
5912 }
5913
5914 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5915 return SWIG_Python_InitShadowInstance(args);
5916 }
5917
5918 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5919 PyObject *resultobj = 0;
5920 int arg1 = (int) 0 ;
5921 int arg2 = (int) 0 ;
5922 int arg3 = (int) 0 ;
5923 int arg4 = (int) 0 ;
5924 wxRect *result = 0 ;
5925 int val1 ;
5926 int ecode1 = 0 ;
5927 int val2 ;
5928 int ecode2 = 0 ;
5929 int val3 ;
5930 int ecode3 = 0 ;
5931 int val4 ;
5932 int ecode4 = 0 ;
5933 PyObject * obj0 = 0 ;
5934 PyObject * obj1 = 0 ;
5935 PyObject * obj2 = 0 ;
5936 PyObject * obj3 = 0 ;
5937 char * kwnames[] = {
5938 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
5939 };
5940
5941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5942 if (obj0) {
5943 ecode1 = SWIG_AsVal_int(obj0, &val1);
5944 if (!SWIG_IsOK(ecode1)) {
5945 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
5946 }
5947 arg1 = static_cast< int >(val1);
5948 }
5949 if (obj1) {
5950 ecode2 = SWIG_AsVal_int(obj1, &val2);
5951 if (!SWIG_IsOK(ecode2)) {
5952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
5953 }
5954 arg2 = static_cast< int >(val2);
5955 }
5956 if (obj2) {
5957 ecode3 = SWIG_AsVal_int(obj2, &val3);
5958 if (!SWIG_IsOK(ecode3)) {
5959 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
5960 }
5961 arg3 = static_cast< int >(val3);
5962 }
5963 if (obj3) {
5964 ecode4 = SWIG_AsVal_int(obj3, &val4);
5965 if (!SWIG_IsOK(ecode4)) {
5966 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
5967 }
5968 arg4 = static_cast< int >(val4);
5969 }
5970 {
5971 PyThreadState* __tstate = wxPyBeginAllowThreads();
5972 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
5973 wxPyEndAllowThreads(__tstate);
5974 if (PyErr_Occurred()) SWIG_fail;
5975 }
5976 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
5977 return resultobj;
5978 fail:
5979 return NULL;
5980 }
5981
5982
5983 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5984 PyObject *resultobj = 0;
5985 wxPoint *arg1 = 0 ;
5986 wxPoint *arg2 = 0 ;
5987 wxRect *result = 0 ;
5988 wxPoint temp1 ;
5989 wxPoint temp2 ;
5990 PyObject * obj0 = 0 ;
5991 PyObject * obj1 = 0 ;
5992 char * kwnames[] = {
5993 (char *) "topLeft",(char *) "bottomRight", NULL
5994 };
5995
5996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
5997 {
5998 arg1 = &temp1;
5999 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6000 }
6001 {
6002 arg2 = &temp2;
6003 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6004 }
6005 {
6006 PyThreadState* __tstate = wxPyBeginAllowThreads();
6007 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6008 wxPyEndAllowThreads(__tstate);
6009 if (PyErr_Occurred()) SWIG_fail;
6010 }
6011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6012 return resultobj;
6013 fail:
6014 return NULL;
6015 }
6016
6017
6018 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6019 PyObject *resultobj = 0;
6020 wxPoint *arg1 = 0 ;
6021 wxSize *arg2 = 0 ;
6022 wxRect *result = 0 ;
6023 wxPoint temp1 ;
6024 wxSize temp2 ;
6025 PyObject * obj0 = 0 ;
6026 PyObject * obj1 = 0 ;
6027 char * kwnames[] = {
6028 (char *) "pos",(char *) "size", NULL
6029 };
6030
6031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6032 {
6033 arg1 = &temp1;
6034 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6035 }
6036 {
6037 arg2 = &temp2;
6038 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6039 }
6040 {
6041 PyThreadState* __tstate = wxPyBeginAllowThreads();
6042 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6043 wxPyEndAllowThreads(__tstate);
6044 if (PyErr_Occurred()) SWIG_fail;
6045 }
6046 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6047 return resultobj;
6048 fail:
6049 return NULL;
6050 }
6051
6052
6053 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6054 PyObject *resultobj = 0;
6055 wxSize *arg1 = 0 ;
6056 wxRect *result = 0 ;
6057 wxSize temp1 ;
6058 PyObject * obj0 = 0 ;
6059 char * kwnames[] = {
6060 (char *) "size", NULL
6061 };
6062
6063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6064 {
6065 arg1 = &temp1;
6066 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6067 }
6068 {
6069 PyThreadState* __tstate = wxPyBeginAllowThreads();
6070 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6071 wxPyEndAllowThreads(__tstate);
6072 if (PyErr_Occurred()) SWIG_fail;
6073 }
6074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6075 return resultobj;
6076 fail:
6077 return NULL;
6078 }
6079
6080
6081 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6082 PyObject *resultobj = 0;
6083 wxRect *arg1 = (wxRect *) 0 ;
6084 void *argp1 = 0 ;
6085 int res1 = 0 ;
6086 PyObject *swig_obj[1] ;
6087
6088 if (!args) SWIG_fail;
6089 swig_obj[0] = args;
6090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6091 if (!SWIG_IsOK(res1)) {
6092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6093 }
6094 arg1 = reinterpret_cast< wxRect * >(argp1);
6095 {
6096 PyThreadState* __tstate = wxPyBeginAllowThreads();
6097 delete arg1;
6098
6099 wxPyEndAllowThreads(__tstate);
6100 if (PyErr_Occurred()) SWIG_fail;
6101 }
6102 resultobj = SWIG_Py_Void();
6103 return resultobj;
6104 fail:
6105 return NULL;
6106 }
6107
6108
6109 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6110 PyObject *resultobj = 0;
6111 wxRect *arg1 = (wxRect *) 0 ;
6112 int result;
6113 void *argp1 = 0 ;
6114 int res1 = 0 ;
6115 PyObject *swig_obj[1] ;
6116
6117 if (!args) SWIG_fail;
6118 swig_obj[0] = args;
6119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6120 if (!SWIG_IsOK(res1)) {
6121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6122 }
6123 arg1 = reinterpret_cast< wxRect * >(argp1);
6124 {
6125 PyThreadState* __tstate = wxPyBeginAllowThreads();
6126 result = (int)((wxRect const *)arg1)->GetX();
6127 wxPyEndAllowThreads(__tstate);
6128 if (PyErr_Occurred()) SWIG_fail;
6129 }
6130 resultobj = SWIG_From_int(static_cast< int >(result));
6131 return resultobj;
6132 fail:
6133 return NULL;
6134 }
6135
6136
6137 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6138 PyObject *resultobj = 0;
6139 wxRect *arg1 = (wxRect *) 0 ;
6140 int arg2 ;
6141 void *argp1 = 0 ;
6142 int res1 = 0 ;
6143 int val2 ;
6144 int ecode2 = 0 ;
6145 PyObject * obj0 = 0 ;
6146 PyObject * obj1 = 0 ;
6147 char * kwnames[] = {
6148 (char *) "self",(char *) "x", NULL
6149 };
6150
6151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6153 if (!SWIG_IsOK(res1)) {
6154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6155 }
6156 arg1 = reinterpret_cast< wxRect * >(argp1);
6157 ecode2 = SWIG_AsVal_int(obj1, &val2);
6158 if (!SWIG_IsOK(ecode2)) {
6159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6160 }
6161 arg2 = static_cast< int >(val2);
6162 {
6163 PyThreadState* __tstate = wxPyBeginAllowThreads();
6164 (arg1)->SetX(arg2);
6165 wxPyEndAllowThreads(__tstate);
6166 if (PyErr_Occurred()) SWIG_fail;
6167 }
6168 resultobj = SWIG_Py_Void();
6169 return resultobj;
6170 fail:
6171 return NULL;
6172 }
6173
6174
6175 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6176 PyObject *resultobj = 0;
6177 wxRect *arg1 = (wxRect *) 0 ;
6178 int result;
6179 void *argp1 = 0 ;
6180 int res1 = 0 ;
6181 PyObject *swig_obj[1] ;
6182
6183 if (!args) SWIG_fail;
6184 swig_obj[0] = args;
6185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6186 if (!SWIG_IsOK(res1)) {
6187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6188 }
6189 arg1 = reinterpret_cast< wxRect * >(argp1);
6190 {
6191 PyThreadState* __tstate = wxPyBeginAllowThreads();
6192 result = (int)(arg1)->GetY();
6193 wxPyEndAllowThreads(__tstate);
6194 if (PyErr_Occurred()) SWIG_fail;
6195 }
6196 resultobj = SWIG_From_int(static_cast< int >(result));
6197 return resultobj;
6198 fail:
6199 return NULL;
6200 }
6201
6202
6203 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6204 PyObject *resultobj = 0;
6205 wxRect *arg1 = (wxRect *) 0 ;
6206 int arg2 ;
6207 void *argp1 = 0 ;
6208 int res1 = 0 ;
6209 int val2 ;
6210 int ecode2 = 0 ;
6211 PyObject * obj0 = 0 ;
6212 PyObject * obj1 = 0 ;
6213 char * kwnames[] = {
6214 (char *) "self",(char *) "y", NULL
6215 };
6216
6217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6219 if (!SWIG_IsOK(res1)) {
6220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6221 }
6222 arg1 = reinterpret_cast< wxRect * >(argp1);
6223 ecode2 = SWIG_AsVal_int(obj1, &val2);
6224 if (!SWIG_IsOK(ecode2)) {
6225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6226 }
6227 arg2 = static_cast< int >(val2);
6228 {
6229 PyThreadState* __tstate = wxPyBeginAllowThreads();
6230 (arg1)->SetY(arg2);
6231 wxPyEndAllowThreads(__tstate);
6232 if (PyErr_Occurred()) SWIG_fail;
6233 }
6234 resultobj = SWIG_Py_Void();
6235 return resultobj;
6236 fail:
6237 return NULL;
6238 }
6239
6240
6241 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6242 PyObject *resultobj = 0;
6243 wxRect *arg1 = (wxRect *) 0 ;
6244 int result;
6245 void *argp1 = 0 ;
6246 int res1 = 0 ;
6247 PyObject *swig_obj[1] ;
6248
6249 if (!args) SWIG_fail;
6250 swig_obj[0] = args;
6251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6252 if (!SWIG_IsOK(res1)) {
6253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6254 }
6255 arg1 = reinterpret_cast< wxRect * >(argp1);
6256 {
6257 PyThreadState* __tstate = wxPyBeginAllowThreads();
6258 result = (int)((wxRect const *)arg1)->GetWidth();
6259 wxPyEndAllowThreads(__tstate);
6260 if (PyErr_Occurred()) SWIG_fail;
6261 }
6262 resultobj = SWIG_From_int(static_cast< int >(result));
6263 return resultobj;
6264 fail:
6265 return NULL;
6266 }
6267
6268
6269 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6270 PyObject *resultobj = 0;
6271 wxRect *arg1 = (wxRect *) 0 ;
6272 int arg2 ;
6273 void *argp1 = 0 ;
6274 int res1 = 0 ;
6275 int val2 ;
6276 int ecode2 = 0 ;
6277 PyObject * obj0 = 0 ;
6278 PyObject * obj1 = 0 ;
6279 char * kwnames[] = {
6280 (char *) "self",(char *) "w", NULL
6281 };
6282
6283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6285 if (!SWIG_IsOK(res1)) {
6286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6287 }
6288 arg1 = reinterpret_cast< wxRect * >(argp1);
6289 ecode2 = SWIG_AsVal_int(obj1, &val2);
6290 if (!SWIG_IsOK(ecode2)) {
6291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6292 }
6293 arg2 = static_cast< int >(val2);
6294 {
6295 PyThreadState* __tstate = wxPyBeginAllowThreads();
6296 (arg1)->SetWidth(arg2);
6297 wxPyEndAllowThreads(__tstate);
6298 if (PyErr_Occurred()) SWIG_fail;
6299 }
6300 resultobj = SWIG_Py_Void();
6301 return resultobj;
6302 fail:
6303 return NULL;
6304 }
6305
6306
6307 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6308 PyObject *resultobj = 0;
6309 wxRect *arg1 = (wxRect *) 0 ;
6310 int result;
6311 void *argp1 = 0 ;
6312 int res1 = 0 ;
6313 PyObject *swig_obj[1] ;
6314
6315 if (!args) SWIG_fail;
6316 swig_obj[0] = args;
6317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6318 if (!SWIG_IsOK(res1)) {
6319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6320 }
6321 arg1 = reinterpret_cast< wxRect * >(argp1);
6322 {
6323 PyThreadState* __tstate = wxPyBeginAllowThreads();
6324 result = (int)((wxRect const *)arg1)->GetHeight();
6325 wxPyEndAllowThreads(__tstate);
6326 if (PyErr_Occurred()) SWIG_fail;
6327 }
6328 resultobj = SWIG_From_int(static_cast< int >(result));
6329 return resultobj;
6330 fail:
6331 return NULL;
6332 }
6333
6334
6335 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6336 PyObject *resultobj = 0;
6337 wxRect *arg1 = (wxRect *) 0 ;
6338 int arg2 ;
6339 void *argp1 = 0 ;
6340 int res1 = 0 ;
6341 int val2 ;
6342 int ecode2 = 0 ;
6343 PyObject * obj0 = 0 ;
6344 PyObject * obj1 = 0 ;
6345 char * kwnames[] = {
6346 (char *) "self",(char *) "h", NULL
6347 };
6348
6349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6351 if (!SWIG_IsOK(res1)) {
6352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6353 }
6354 arg1 = reinterpret_cast< wxRect * >(argp1);
6355 ecode2 = SWIG_AsVal_int(obj1, &val2);
6356 if (!SWIG_IsOK(ecode2)) {
6357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6358 }
6359 arg2 = static_cast< int >(val2);
6360 {
6361 PyThreadState* __tstate = wxPyBeginAllowThreads();
6362 (arg1)->SetHeight(arg2);
6363 wxPyEndAllowThreads(__tstate);
6364 if (PyErr_Occurred()) SWIG_fail;
6365 }
6366 resultobj = SWIG_Py_Void();
6367 return resultobj;
6368 fail:
6369 return NULL;
6370 }
6371
6372
6373 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6374 PyObject *resultobj = 0;
6375 wxRect *arg1 = (wxRect *) 0 ;
6376 wxPoint result;
6377 void *argp1 = 0 ;
6378 int res1 = 0 ;
6379 PyObject *swig_obj[1] ;
6380
6381 if (!args) SWIG_fail;
6382 swig_obj[0] = args;
6383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6384 if (!SWIG_IsOK(res1)) {
6385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6386 }
6387 arg1 = reinterpret_cast< wxRect * >(argp1);
6388 {
6389 PyThreadState* __tstate = wxPyBeginAllowThreads();
6390 result = ((wxRect const *)arg1)->GetPosition();
6391 wxPyEndAllowThreads(__tstate);
6392 if (PyErr_Occurred()) SWIG_fail;
6393 }
6394 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6395 return resultobj;
6396 fail:
6397 return NULL;
6398 }
6399
6400
6401 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6402 PyObject *resultobj = 0;
6403 wxRect *arg1 = (wxRect *) 0 ;
6404 wxPoint *arg2 = 0 ;
6405 void *argp1 = 0 ;
6406 int res1 = 0 ;
6407 wxPoint temp2 ;
6408 PyObject * obj0 = 0 ;
6409 PyObject * obj1 = 0 ;
6410 char * kwnames[] = {
6411 (char *) "self",(char *) "p", NULL
6412 };
6413
6414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6416 if (!SWIG_IsOK(res1)) {
6417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6418 }
6419 arg1 = reinterpret_cast< wxRect * >(argp1);
6420 {
6421 arg2 = &temp2;
6422 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6423 }
6424 {
6425 PyThreadState* __tstate = wxPyBeginAllowThreads();
6426 (arg1)->SetPosition((wxPoint const &)*arg2);
6427 wxPyEndAllowThreads(__tstate);
6428 if (PyErr_Occurred()) SWIG_fail;
6429 }
6430 resultobj = SWIG_Py_Void();
6431 return resultobj;
6432 fail:
6433 return NULL;
6434 }
6435
6436
6437 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6438 PyObject *resultobj = 0;
6439 wxRect *arg1 = (wxRect *) 0 ;
6440 wxSize result;
6441 void *argp1 = 0 ;
6442 int res1 = 0 ;
6443 PyObject *swig_obj[1] ;
6444
6445 if (!args) SWIG_fail;
6446 swig_obj[0] = args;
6447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6448 if (!SWIG_IsOK(res1)) {
6449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6450 }
6451 arg1 = reinterpret_cast< wxRect * >(argp1);
6452 {
6453 PyThreadState* __tstate = wxPyBeginAllowThreads();
6454 result = ((wxRect const *)arg1)->GetSize();
6455 wxPyEndAllowThreads(__tstate);
6456 if (PyErr_Occurred()) SWIG_fail;
6457 }
6458 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6459 return resultobj;
6460 fail:
6461 return NULL;
6462 }
6463
6464
6465 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6466 PyObject *resultobj = 0;
6467 wxRect *arg1 = (wxRect *) 0 ;
6468 wxSize *arg2 = 0 ;
6469 void *argp1 = 0 ;
6470 int res1 = 0 ;
6471 wxSize temp2 ;
6472 PyObject * obj0 = 0 ;
6473 PyObject * obj1 = 0 ;
6474 char * kwnames[] = {
6475 (char *) "self",(char *) "s", NULL
6476 };
6477
6478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6480 if (!SWIG_IsOK(res1)) {
6481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6482 }
6483 arg1 = reinterpret_cast< wxRect * >(argp1);
6484 {
6485 arg2 = &temp2;
6486 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6487 }
6488 {
6489 PyThreadState* __tstate = wxPyBeginAllowThreads();
6490 (arg1)->SetSize((wxSize const &)*arg2);
6491 wxPyEndAllowThreads(__tstate);
6492 if (PyErr_Occurred()) SWIG_fail;
6493 }
6494 resultobj = SWIG_Py_Void();
6495 return resultobj;
6496 fail:
6497 return NULL;
6498 }
6499
6500
6501 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6502 PyObject *resultobj = 0;
6503 wxRect *arg1 = (wxRect *) 0 ;
6504 bool result;
6505 void *argp1 = 0 ;
6506 int res1 = 0 ;
6507 PyObject *swig_obj[1] ;
6508
6509 if (!args) SWIG_fail;
6510 swig_obj[0] = args;
6511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6512 if (!SWIG_IsOK(res1)) {
6513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6514 }
6515 arg1 = reinterpret_cast< wxRect * >(argp1);
6516 {
6517 PyThreadState* __tstate = wxPyBeginAllowThreads();
6518 result = (bool)((wxRect const *)arg1)->IsEmpty();
6519 wxPyEndAllowThreads(__tstate);
6520 if (PyErr_Occurred()) SWIG_fail;
6521 }
6522 {
6523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6524 }
6525 return resultobj;
6526 fail:
6527 return NULL;
6528 }
6529
6530
6531 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6532 PyObject *resultobj = 0;
6533 wxRect *arg1 = (wxRect *) 0 ;
6534 wxPoint result;
6535 void *argp1 = 0 ;
6536 int res1 = 0 ;
6537 PyObject *swig_obj[1] ;
6538
6539 if (!args) SWIG_fail;
6540 swig_obj[0] = args;
6541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6542 if (!SWIG_IsOK(res1)) {
6543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6544 }
6545 arg1 = reinterpret_cast< wxRect * >(argp1);
6546 {
6547 PyThreadState* __tstate = wxPyBeginAllowThreads();
6548 result = ((wxRect const *)arg1)->GetTopLeft();
6549 wxPyEndAllowThreads(__tstate);
6550 if (PyErr_Occurred()) SWIG_fail;
6551 }
6552 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6553 return resultobj;
6554 fail:
6555 return NULL;
6556 }
6557
6558
6559 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6560 PyObject *resultobj = 0;
6561 wxRect *arg1 = (wxRect *) 0 ;
6562 wxPoint *arg2 = 0 ;
6563 void *argp1 = 0 ;
6564 int res1 = 0 ;
6565 wxPoint temp2 ;
6566 PyObject * obj0 = 0 ;
6567 PyObject * obj1 = 0 ;
6568 char * kwnames[] = {
6569 (char *) "self",(char *) "p", NULL
6570 };
6571
6572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6574 if (!SWIG_IsOK(res1)) {
6575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6576 }
6577 arg1 = reinterpret_cast< wxRect * >(argp1);
6578 {
6579 arg2 = &temp2;
6580 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6581 }
6582 {
6583 PyThreadState* __tstate = wxPyBeginAllowThreads();
6584 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6585 wxPyEndAllowThreads(__tstate);
6586 if (PyErr_Occurred()) SWIG_fail;
6587 }
6588 resultobj = SWIG_Py_Void();
6589 return resultobj;
6590 fail:
6591 return NULL;
6592 }
6593
6594
6595 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6596 PyObject *resultobj = 0;
6597 wxRect *arg1 = (wxRect *) 0 ;
6598 wxPoint result;
6599 void *argp1 = 0 ;
6600 int res1 = 0 ;
6601 PyObject *swig_obj[1] ;
6602
6603 if (!args) SWIG_fail;
6604 swig_obj[0] = args;
6605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6606 if (!SWIG_IsOK(res1)) {
6607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6608 }
6609 arg1 = reinterpret_cast< wxRect * >(argp1);
6610 {
6611 PyThreadState* __tstate = wxPyBeginAllowThreads();
6612 result = ((wxRect const *)arg1)->GetBottomRight();
6613 wxPyEndAllowThreads(__tstate);
6614 if (PyErr_Occurred()) SWIG_fail;
6615 }
6616 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6617 return resultobj;
6618 fail:
6619 return NULL;
6620 }
6621
6622
6623 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6624 PyObject *resultobj = 0;
6625 wxRect *arg1 = (wxRect *) 0 ;
6626 wxPoint *arg2 = 0 ;
6627 void *argp1 = 0 ;
6628 int res1 = 0 ;
6629 wxPoint temp2 ;
6630 PyObject * obj0 = 0 ;
6631 PyObject * obj1 = 0 ;
6632 char * kwnames[] = {
6633 (char *) "self",(char *) "p", NULL
6634 };
6635
6636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6638 if (!SWIG_IsOK(res1)) {
6639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6640 }
6641 arg1 = reinterpret_cast< wxRect * >(argp1);
6642 {
6643 arg2 = &temp2;
6644 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6645 }
6646 {
6647 PyThreadState* __tstate = wxPyBeginAllowThreads();
6648 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6649 wxPyEndAllowThreads(__tstate);
6650 if (PyErr_Occurred()) SWIG_fail;
6651 }
6652 resultobj = SWIG_Py_Void();
6653 return resultobj;
6654 fail:
6655 return NULL;
6656 }
6657
6658
6659 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6660 PyObject *resultobj = 0;
6661 wxRect *arg1 = (wxRect *) 0 ;
6662 int result;
6663 void *argp1 = 0 ;
6664 int res1 = 0 ;
6665 PyObject *swig_obj[1] ;
6666
6667 if (!args) SWIG_fail;
6668 swig_obj[0] = args;
6669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6670 if (!SWIG_IsOK(res1)) {
6671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6672 }
6673 arg1 = reinterpret_cast< wxRect * >(argp1);
6674 {
6675 PyThreadState* __tstate = wxPyBeginAllowThreads();
6676 result = (int)((wxRect const *)arg1)->GetLeft();
6677 wxPyEndAllowThreads(__tstate);
6678 if (PyErr_Occurred()) SWIG_fail;
6679 }
6680 resultobj = SWIG_From_int(static_cast< int >(result));
6681 return resultobj;
6682 fail:
6683 return NULL;
6684 }
6685
6686
6687 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6688 PyObject *resultobj = 0;
6689 wxRect *arg1 = (wxRect *) 0 ;
6690 int result;
6691 void *argp1 = 0 ;
6692 int res1 = 0 ;
6693 PyObject *swig_obj[1] ;
6694
6695 if (!args) SWIG_fail;
6696 swig_obj[0] = args;
6697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6698 if (!SWIG_IsOK(res1)) {
6699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6700 }
6701 arg1 = reinterpret_cast< wxRect * >(argp1);
6702 {
6703 PyThreadState* __tstate = wxPyBeginAllowThreads();
6704 result = (int)((wxRect const *)arg1)->GetTop();
6705 wxPyEndAllowThreads(__tstate);
6706 if (PyErr_Occurred()) SWIG_fail;
6707 }
6708 resultobj = SWIG_From_int(static_cast< int >(result));
6709 return resultobj;
6710 fail:
6711 return NULL;
6712 }
6713
6714
6715 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6716 PyObject *resultobj = 0;
6717 wxRect *arg1 = (wxRect *) 0 ;
6718 int result;
6719 void *argp1 = 0 ;
6720 int res1 = 0 ;
6721 PyObject *swig_obj[1] ;
6722
6723 if (!args) SWIG_fail;
6724 swig_obj[0] = args;
6725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6726 if (!SWIG_IsOK(res1)) {
6727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6728 }
6729 arg1 = reinterpret_cast< wxRect * >(argp1);
6730 {
6731 PyThreadState* __tstate = wxPyBeginAllowThreads();
6732 result = (int)((wxRect const *)arg1)->GetBottom();
6733 wxPyEndAllowThreads(__tstate);
6734 if (PyErr_Occurred()) SWIG_fail;
6735 }
6736 resultobj = SWIG_From_int(static_cast< int >(result));
6737 return resultobj;
6738 fail:
6739 return NULL;
6740 }
6741
6742
6743 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6744 PyObject *resultobj = 0;
6745 wxRect *arg1 = (wxRect *) 0 ;
6746 int result;
6747 void *argp1 = 0 ;
6748 int res1 = 0 ;
6749 PyObject *swig_obj[1] ;
6750
6751 if (!args) SWIG_fail;
6752 swig_obj[0] = args;
6753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6754 if (!SWIG_IsOK(res1)) {
6755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6756 }
6757 arg1 = reinterpret_cast< wxRect * >(argp1);
6758 {
6759 PyThreadState* __tstate = wxPyBeginAllowThreads();
6760 result = (int)((wxRect const *)arg1)->GetRight();
6761 wxPyEndAllowThreads(__tstate);
6762 if (PyErr_Occurred()) SWIG_fail;
6763 }
6764 resultobj = SWIG_From_int(static_cast< int >(result));
6765 return resultobj;
6766 fail:
6767 return NULL;
6768 }
6769
6770
6771 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6772 PyObject *resultobj = 0;
6773 wxRect *arg1 = (wxRect *) 0 ;
6774 int arg2 ;
6775 void *argp1 = 0 ;
6776 int res1 = 0 ;
6777 int val2 ;
6778 int ecode2 = 0 ;
6779 PyObject * obj0 = 0 ;
6780 PyObject * obj1 = 0 ;
6781 char * kwnames[] = {
6782 (char *) "self",(char *) "left", NULL
6783 };
6784
6785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6787 if (!SWIG_IsOK(res1)) {
6788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6789 }
6790 arg1 = reinterpret_cast< wxRect * >(argp1);
6791 ecode2 = SWIG_AsVal_int(obj1, &val2);
6792 if (!SWIG_IsOK(ecode2)) {
6793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6794 }
6795 arg2 = static_cast< int >(val2);
6796 {
6797 PyThreadState* __tstate = wxPyBeginAllowThreads();
6798 (arg1)->SetLeft(arg2);
6799 wxPyEndAllowThreads(__tstate);
6800 if (PyErr_Occurred()) SWIG_fail;
6801 }
6802 resultobj = SWIG_Py_Void();
6803 return resultobj;
6804 fail:
6805 return NULL;
6806 }
6807
6808
6809 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6810 PyObject *resultobj = 0;
6811 wxRect *arg1 = (wxRect *) 0 ;
6812 int arg2 ;
6813 void *argp1 = 0 ;
6814 int res1 = 0 ;
6815 int val2 ;
6816 int ecode2 = 0 ;
6817 PyObject * obj0 = 0 ;
6818 PyObject * obj1 = 0 ;
6819 char * kwnames[] = {
6820 (char *) "self",(char *) "right", NULL
6821 };
6822
6823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6825 if (!SWIG_IsOK(res1)) {
6826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6827 }
6828 arg1 = reinterpret_cast< wxRect * >(argp1);
6829 ecode2 = SWIG_AsVal_int(obj1, &val2);
6830 if (!SWIG_IsOK(ecode2)) {
6831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6832 }
6833 arg2 = static_cast< int >(val2);
6834 {
6835 PyThreadState* __tstate = wxPyBeginAllowThreads();
6836 (arg1)->SetRight(arg2);
6837 wxPyEndAllowThreads(__tstate);
6838 if (PyErr_Occurred()) SWIG_fail;
6839 }
6840 resultobj = SWIG_Py_Void();
6841 return resultobj;
6842 fail:
6843 return NULL;
6844 }
6845
6846
6847 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6848 PyObject *resultobj = 0;
6849 wxRect *arg1 = (wxRect *) 0 ;
6850 int arg2 ;
6851 void *argp1 = 0 ;
6852 int res1 = 0 ;
6853 int val2 ;
6854 int ecode2 = 0 ;
6855 PyObject * obj0 = 0 ;
6856 PyObject * obj1 = 0 ;
6857 char * kwnames[] = {
6858 (char *) "self",(char *) "top", NULL
6859 };
6860
6861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6863 if (!SWIG_IsOK(res1)) {
6864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6865 }
6866 arg1 = reinterpret_cast< wxRect * >(argp1);
6867 ecode2 = SWIG_AsVal_int(obj1, &val2);
6868 if (!SWIG_IsOK(ecode2)) {
6869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6870 }
6871 arg2 = static_cast< int >(val2);
6872 {
6873 PyThreadState* __tstate = wxPyBeginAllowThreads();
6874 (arg1)->SetTop(arg2);
6875 wxPyEndAllowThreads(__tstate);
6876 if (PyErr_Occurred()) SWIG_fail;
6877 }
6878 resultobj = SWIG_Py_Void();
6879 return resultobj;
6880 fail:
6881 return NULL;
6882 }
6883
6884
6885 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6886 PyObject *resultobj = 0;
6887 wxRect *arg1 = (wxRect *) 0 ;
6888 int arg2 ;
6889 void *argp1 = 0 ;
6890 int res1 = 0 ;
6891 int val2 ;
6892 int ecode2 = 0 ;
6893 PyObject * obj0 = 0 ;
6894 PyObject * obj1 = 0 ;
6895 char * kwnames[] = {
6896 (char *) "self",(char *) "bottom", NULL
6897 };
6898
6899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6901 if (!SWIG_IsOK(res1)) {
6902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6903 }
6904 arg1 = reinterpret_cast< wxRect * >(argp1);
6905 ecode2 = SWIG_AsVal_int(obj1, &val2);
6906 if (!SWIG_IsOK(ecode2)) {
6907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
6908 }
6909 arg2 = static_cast< int >(val2);
6910 {
6911 PyThreadState* __tstate = wxPyBeginAllowThreads();
6912 (arg1)->SetBottom(arg2);
6913 wxPyEndAllowThreads(__tstate);
6914 if (PyErr_Occurred()) SWIG_fail;
6915 }
6916 resultobj = SWIG_Py_Void();
6917 return resultobj;
6918 fail:
6919 return NULL;
6920 }
6921
6922
6923 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6924 PyObject *resultobj = 0;
6925 wxRect *arg1 = (wxRect *) 0 ;
6926 int arg2 ;
6927 int arg3 ;
6928 wxRect *result = 0 ;
6929 void *argp1 = 0 ;
6930 int res1 = 0 ;
6931 int val2 ;
6932 int ecode2 = 0 ;
6933 int val3 ;
6934 int ecode3 = 0 ;
6935 PyObject * obj0 = 0 ;
6936 PyObject * obj1 = 0 ;
6937 PyObject * obj2 = 0 ;
6938 char * kwnames[] = {
6939 (char *) "self",(char *) "dx",(char *) "dy", NULL
6940 };
6941
6942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6944 if (!SWIG_IsOK(res1)) {
6945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
6946 }
6947 arg1 = reinterpret_cast< wxRect * >(argp1);
6948 ecode2 = SWIG_AsVal_int(obj1, &val2);
6949 if (!SWIG_IsOK(ecode2)) {
6950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
6951 }
6952 arg2 = static_cast< int >(val2);
6953 ecode3 = SWIG_AsVal_int(obj2, &val3);
6954 if (!SWIG_IsOK(ecode3)) {
6955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
6956 }
6957 arg3 = static_cast< int >(val3);
6958 {
6959 PyThreadState* __tstate = wxPyBeginAllowThreads();
6960 {
6961 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
6962 result = (wxRect *) &_result_ref;
6963 }
6964 wxPyEndAllowThreads(__tstate);
6965 if (PyErr_Occurred()) SWIG_fail;
6966 }
6967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
6968 return resultobj;
6969 fail:
6970 return NULL;
6971 }
6972
6973
6974 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6975 PyObject *resultobj = 0;
6976 wxRect *arg1 = (wxRect *) 0 ;
6977 int arg2 ;
6978 int arg3 ;
6979 wxRect *result = 0 ;
6980 void *argp1 = 0 ;
6981 int res1 = 0 ;
6982 int val2 ;
6983 int ecode2 = 0 ;
6984 int val3 ;
6985 int ecode3 = 0 ;
6986 PyObject * obj0 = 0 ;
6987 PyObject * obj1 = 0 ;
6988 PyObject * obj2 = 0 ;
6989 char * kwnames[] = {
6990 (char *) "self",(char *) "dx",(char *) "dy", NULL
6991 };
6992
6993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6995 if (!SWIG_IsOK(res1)) {
6996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
6997 }
6998 arg1 = reinterpret_cast< wxRect * >(argp1);
6999 ecode2 = SWIG_AsVal_int(obj1, &val2);
7000 if (!SWIG_IsOK(ecode2)) {
7001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7002 }
7003 arg2 = static_cast< int >(val2);
7004 ecode3 = SWIG_AsVal_int(obj2, &val3);
7005 if (!SWIG_IsOK(ecode3)) {
7006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7007 }
7008 arg3 = static_cast< int >(val3);
7009 {
7010 PyThreadState* __tstate = wxPyBeginAllowThreads();
7011 {
7012 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7013 result = (wxRect *) &_result_ref;
7014 }
7015 wxPyEndAllowThreads(__tstate);
7016 if (PyErr_Occurred()) SWIG_fail;
7017 }
7018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7019 return resultobj;
7020 fail:
7021 return NULL;
7022 }
7023
7024
7025 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7026 PyObject *resultobj = 0;
7027 wxRect *arg1 = (wxRect *) 0 ;
7028 int arg2 ;
7029 int arg3 ;
7030 void *argp1 = 0 ;
7031 int res1 = 0 ;
7032 int val2 ;
7033 int ecode2 = 0 ;
7034 int val3 ;
7035 int ecode3 = 0 ;
7036 PyObject * obj0 = 0 ;
7037 PyObject * obj1 = 0 ;
7038 PyObject * obj2 = 0 ;
7039 char * kwnames[] = {
7040 (char *) "self",(char *) "dx",(char *) "dy", NULL
7041 };
7042
7043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7045 if (!SWIG_IsOK(res1)) {
7046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7047 }
7048 arg1 = reinterpret_cast< wxRect * >(argp1);
7049 ecode2 = SWIG_AsVal_int(obj1, &val2);
7050 if (!SWIG_IsOK(ecode2)) {
7051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7052 }
7053 arg2 = static_cast< int >(val2);
7054 ecode3 = SWIG_AsVal_int(obj2, &val3);
7055 if (!SWIG_IsOK(ecode3)) {
7056 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7057 }
7058 arg3 = static_cast< int >(val3);
7059 {
7060 PyThreadState* __tstate = wxPyBeginAllowThreads();
7061 (arg1)->Offset(arg2,arg3);
7062 wxPyEndAllowThreads(__tstate);
7063 if (PyErr_Occurred()) SWIG_fail;
7064 }
7065 resultobj = SWIG_Py_Void();
7066 return resultobj;
7067 fail:
7068 return NULL;
7069 }
7070
7071
7072 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7073 PyObject *resultobj = 0;
7074 wxRect *arg1 = (wxRect *) 0 ;
7075 wxPoint *arg2 = 0 ;
7076 void *argp1 = 0 ;
7077 int res1 = 0 ;
7078 wxPoint temp2 ;
7079 PyObject * obj0 = 0 ;
7080 PyObject * obj1 = 0 ;
7081 char * kwnames[] = {
7082 (char *) "self",(char *) "pt", NULL
7083 };
7084
7085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7087 if (!SWIG_IsOK(res1)) {
7088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7089 }
7090 arg1 = reinterpret_cast< wxRect * >(argp1);
7091 {
7092 arg2 = &temp2;
7093 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7094 }
7095 {
7096 PyThreadState* __tstate = wxPyBeginAllowThreads();
7097 (arg1)->Offset((wxPoint const &)*arg2);
7098 wxPyEndAllowThreads(__tstate);
7099 if (PyErr_Occurred()) SWIG_fail;
7100 }
7101 resultobj = SWIG_Py_Void();
7102 return resultobj;
7103 fail:
7104 return NULL;
7105 }
7106
7107
7108 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7109 PyObject *resultobj = 0;
7110 wxRect *arg1 = (wxRect *) 0 ;
7111 wxRect *arg2 = 0 ;
7112 wxRect result;
7113 void *argp1 = 0 ;
7114 int res1 = 0 ;
7115 wxRect temp2 ;
7116 PyObject * obj0 = 0 ;
7117 PyObject * obj1 = 0 ;
7118 char * kwnames[] = {
7119 (char *) "self",(char *) "rect", NULL
7120 };
7121
7122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7124 if (!SWIG_IsOK(res1)) {
7125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7126 }
7127 arg1 = reinterpret_cast< wxRect * >(argp1);
7128 {
7129 arg2 = &temp2;
7130 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7131 }
7132 {
7133 PyThreadState* __tstate = wxPyBeginAllowThreads();
7134 result = (arg1)->Intersect((wxRect const &)*arg2);
7135 wxPyEndAllowThreads(__tstate);
7136 if (PyErr_Occurred()) SWIG_fail;
7137 }
7138 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7139 return resultobj;
7140 fail:
7141 return NULL;
7142 }
7143
7144
7145 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7146 PyObject *resultobj = 0;
7147 wxRect *arg1 = (wxRect *) 0 ;
7148 wxRect *arg2 = 0 ;
7149 wxRect result;
7150 void *argp1 = 0 ;
7151 int res1 = 0 ;
7152 wxRect temp2 ;
7153 PyObject * obj0 = 0 ;
7154 PyObject * obj1 = 0 ;
7155 char * kwnames[] = {
7156 (char *) "self",(char *) "rect", NULL
7157 };
7158
7159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7161 if (!SWIG_IsOK(res1)) {
7162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7163 }
7164 arg1 = reinterpret_cast< wxRect * >(argp1);
7165 {
7166 arg2 = &temp2;
7167 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7168 }
7169 {
7170 PyThreadState* __tstate = wxPyBeginAllowThreads();
7171 result = (arg1)->Union((wxRect const &)*arg2);
7172 wxPyEndAllowThreads(__tstate);
7173 if (PyErr_Occurred()) SWIG_fail;
7174 }
7175 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7176 return resultobj;
7177 fail:
7178 return NULL;
7179 }
7180
7181
7182 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7183 PyObject *resultobj = 0;
7184 wxRect *arg1 = (wxRect *) 0 ;
7185 wxRect *arg2 = 0 ;
7186 wxRect result;
7187 void *argp1 = 0 ;
7188 int res1 = 0 ;
7189 wxRect temp2 ;
7190 PyObject * obj0 = 0 ;
7191 PyObject * obj1 = 0 ;
7192 char * kwnames[] = {
7193 (char *) "self",(char *) "rect", NULL
7194 };
7195
7196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7198 if (!SWIG_IsOK(res1)) {
7199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7200 }
7201 arg1 = reinterpret_cast< wxRect * >(argp1);
7202 {
7203 arg2 = &temp2;
7204 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7205 }
7206 {
7207 PyThreadState* __tstate = wxPyBeginAllowThreads();
7208 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7209 wxPyEndAllowThreads(__tstate);
7210 if (PyErr_Occurred()) SWIG_fail;
7211 }
7212 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7213 return resultobj;
7214 fail:
7215 return NULL;
7216 }
7217
7218
7219 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7220 PyObject *resultobj = 0;
7221 wxRect *arg1 = (wxRect *) 0 ;
7222 wxRect *arg2 = 0 ;
7223 wxRect *result = 0 ;
7224 void *argp1 = 0 ;
7225 int res1 = 0 ;
7226 wxRect temp2 ;
7227 PyObject * obj0 = 0 ;
7228 PyObject * obj1 = 0 ;
7229 char * kwnames[] = {
7230 (char *) "self",(char *) "rect", NULL
7231 };
7232
7233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7235 if (!SWIG_IsOK(res1)) {
7236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7237 }
7238 arg1 = reinterpret_cast< wxRect * >(argp1);
7239 {
7240 arg2 = &temp2;
7241 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7242 }
7243 {
7244 PyThreadState* __tstate = wxPyBeginAllowThreads();
7245 {
7246 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7247 result = (wxRect *) &_result_ref;
7248 }
7249 wxPyEndAllowThreads(__tstate);
7250 if (PyErr_Occurred()) SWIG_fail;
7251 }
7252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7253 return resultobj;
7254 fail:
7255 return NULL;
7256 }
7257
7258
7259 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7260 PyObject *resultobj = 0;
7261 wxRect *arg1 = (wxRect *) 0 ;
7262 wxRect *arg2 = 0 ;
7263 bool result;
7264 void *argp1 = 0 ;
7265 int res1 = 0 ;
7266 wxRect temp2 ;
7267 PyObject * obj0 = 0 ;
7268 PyObject * obj1 = 0 ;
7269 char * kwnames[] = {
7270 (char *) "self",(char *) "rect", NULL
7271 };
7272
7273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7275 if (!SWIG_IsOK(res1)) {
7276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect const *""'");
7277 }
7278 arg1 = reinterpret_cast< wxRect * >(argp1);
7279 {
7280 arg2 = &temp2;
7281 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7282 }
7283 {
7284 PyThreadState* __tstate = wxPyBeginAllowThreads();
7285 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
7286 wxPyEndAllowThreads(__tstate);
7287 if (PyErr_Occurred()) SWIG_fail;
7288 }
7289 {
7290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7291 }
7292 return resultobj;
7293 fail:
7294 return NULL;
7295 }
7296
7297
7298 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7299 PyObject *resultobj = 0;
7300 wxRect *arg1 = (wxRect *) 0 ;
7301 wxRect *arg2 = 0 ;
7302 bool result;
7303 void *argp1 = 0 ;
7304 int res1 = 0 ;
7305 wxRect temp2 ;
7306 PyObject * obj0 = 0 ;
7307 PyObject * obj1 = 0 ;
7308 char * kwnames[] = {
7309 (char *) "self",(char *) "rect", NULL
7310 };
7311
7312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7314 if (!SWIG_IsOK(res1)) {
7315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect const *""'");
7316 }
7317 arg1 = reinterpret_cast< wxRect * >(argp1);
7318 {
7319 arg2 = &temp2;
7320 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7321 }
7322 {
7323 PyThreadState* __tstate = wxPyBeginAllowThreads();
7324 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
7325 wxPyEndAllowThreads(__tstate);
7326 if (PyErr_Occurred()) SWIG_fail;
7327 }
7328 {
7329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7330 }
7331 return resultobj;
7332 fail:
7333 return NULL;
7334 }
7335
7336
7337 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7338 PyObject *resultobj = 0;
7339 wxRect *arg1 = (wxRect *) 0 ;
7340 int arg2 ;
7341 int arg3 ;
7342 bool result;
7343 void *argp1 = 0 ;
7344 int res1 = 0 ;
7345 int val2 ;
7346 int ecode2 = 0 ;
7347 int val3 ;
7348 int ecode3 = 0 ;
7349 PyObject * obj0 = 0 ;
7350 PyObject * obj1 = 0 ;
7351 PyObject * obj2 = 0 ;
7352 char * kwnames[] = {
7353 (char *) "self",(char *) "x",(char *) "y", NULL
7354 };
7355
7356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7358 if (!SWIG_IsOK(res1)) {
7359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7360 }
7361 arg1 = reinterpret_cast< wxRect * >(argp1);
7362 ecode2 = SWIG_AsVal_int(obj1, &val2);
7363 if (!SWIG_IsOK(ecode2)) {
7364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7365 }
7366 arg2 = static_cast< int >(val2);
7367 ecode3 = SWIG_AsVal_int(obj2, &val3);
7368 if (!SWIG_IsOK(ecode3)) {
7369 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7370 }
7371 arg3 = static_cast< int >(val3);
7372 {
7373 PyThreadState* __tstate = wxPyBeginAllowThreads();
7374 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7375 wxPyEndAllowThreads(__tstate);
7376 if (PyErr_Occurred()) SWIG_fail;
7377 }
7378 {
7379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7380 }
7381 return resultobj;
7382 fail:
7383 return NULL;
7384 }
7385
7386
7387 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7388 PyObject *resultobj = 0;
7389 wxRect *arg1 = (wxRect *) 0 ;
7390 wxPoint *arg2 = 0 ;
7391 bool result;
7392 void *argp1 = 0 ;
7393 int res1 = 0 ;
7394 wxPoint temp2 ;
7395 PyObject * obj0 = 0 ;
7396 PyObject * obj1 = 0 ;
7397 char * kwnames[] = {
7398 (char *) "self",(char *) "pt", NULL
7399 };
7400
7401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7403 if (!SWIG_IsOK(res1)) {
7404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7405 }
7406 arg1 = reinterpret_cast< wxRect * >(argp1);
7407 {
7408 arg2 = &temp2;
7409 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7410 }
7411 {
7412 PyThreadState* __tstate = wxPyBeginAllowThreads();
7413 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7414 wxPyEndAllowThreads(__tstate);
7415 if (PyErr_Occurred()) SWIG_fail;
7416 }
7417 {
7418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7419 }
7420 return resultobj;
7421 fail:
7422 return NULL;
7423 }
7424
7425
7426 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7427 PyObject *resultobj = 0;
7428 wxRect *arg1 = (wxRect *) 0 ;
7429 wxRect *arg2 = 0 ;
7430 bool result;
7431 void *argp1 = 0 ;
7432 int res1 = 0 ;
7433 wxRect temp2 ;
7434 PyObject * obj0 = 0 ;
7435 PyObject * obj1 = 0 ;
7436 char * kwnames[] = {
7437 (char *) "self",(char *) "rect", NULL
7438 };
7439
7440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7442 if (!SWIG_IsOK(res1)) {
7443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7444 }
7445 arg1 = reinterpret_cast< wxRect * >(argp1);
7446 {
7447 arg2 = &temp2;
7448 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7449 }
7450 {
7451 PyThreadState* __tstate = wxPyBeginAllowThreads();
7452 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7453 wxPyEndAllowThreads(__tstate);
7454 if (PyErr_Occurred()) SWIG_fail;
7455 }
7456 {
7457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7458 }
7459 return resultobj;
7460 fail:
7461 return NULL;
7462 }
7463
7464
7465 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7466 PyObject *resultobj = 0;
7467 wxRect *arg1 = (wxRect *) 0 ;
7468 wxRect *arg2 = 0 ;
7469 int arg3 = (int) wxBOTH ;
7470 wxRect result;
7471 void *argp1 = 0 ;
7472 int res1 = 0 ;
7473 wxRect temp2 ;
7474 int val3 ;
7475 int ecode3 = 0 ;
7476 PyObject * obj0 = 0 ;
7477 PyObject * obj1 = 0 ;
7478 PyObject * obj2 = 0 ;
7479 char * kwnames[] = {
7480 (char *) "self",(char *) "r",(char *) "dir", NULL
7481 };
7482
7483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7485 if (!SWIG_IsOK(res1)) {
7486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7487 }
7488 arg1 = reinterpret_cast< wxRect * >(argp1);
7489 {
7490 arg2 = &temp2;
7491 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7492 }
7493 if (obj2) {
7494 ecode3 = SWIG_AsVal_int(obj2, &val3);
7495 if (!SWIG_IsOK(ecode3)) {
7496 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7497 }
7498 arg3 = static_cast< int >(val3);
7499 }
7500 {
7501 PyThreadState* __tstate = wxPyBeginAllowThreads();
7502 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7503 wxPyEndAllowThreads(__tstate);
7504 if (PyErr_Occurred()) SWIG_fail;
7505 }
7506 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7507 return resultobj;
7508 fail:
7509 return NULL;
7510 }
7511
7512
7513 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7514 PyObject *resultobj = 0;
7515 wxRect *arg1 = (wxRect *) 0 ;
7516 int arg2 ;
7517 void *argp1 = 0 ;
7518 int res1 = 0 ;
7519 int val2 ;
7520 int ecode2 = 0 ;
7521 PyObject *swig_obj[2] ;
7522
7523 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7525 if (!SWIG_IsOK(res1)) {
7526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7527 }
7528 arg1 = reinterpret_cast< wxRect * >(argp1);
7529 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7530 if (!SWIG_IsOK(ecode2)) {
7531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7532 }
7533 arg2 = static_cast< int >(val2);
7534 if (arg1) (arg1)->x = arg2;
7535
7536 resultobj = SWIG_Py_Void();
7537 return resultobj;
7538 fail:
7539 return NULL;
7540 }
7541
7542
7543 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7544 PyObject *resultobj = 0;
7545 wxRect *arg1 = (wxRect *) 0 ;
7546 int result;
7547 void *argp1 = 0 ;
7548 int res1 = 0 ;
7549 PyObject *swig_obj[1] ;
7550
7551 if (!args) SWIG_fail;
7552 swig_obj[0] = args;
7553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7554 if (!SWIG_IsOK(res1)) {
7555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7556 }
7557 arg1 = reinterpret_cast< wxRect * >(argp1);
7558 result = (int) ((arg1)->x);
7559 resultobj = SWIG_From_int(static_cast< int >(result));
7560 return resultobj;
7561 fail:
7562 return NULL;
7563 }
7564
7565
7566 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7567 PyObject *resultobj = 0;
7568 wxRect *arg1 = (wxRect *) 0 ;
7569 int arg2 ;
7570 void *argp1 = 0 ;
7571 int res1 = 0 ;
7572 int val2 ;
7573 int ecode2 = 0 ;
7574 PyObject *swig_obj[2] ;
7575
7576 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7578 if (!SWIG_IsOK(res1)) {
7579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7580 }
7581 arg1 = reinterpret_cast< wxRect * >(argp1);
7582 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7583 if (!SWIG_IsOK(ecode2)) {
7584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7585 }
7586 arg2 = static_cast< int >(val2);
7587 if (arg1) (arg1)->y = arg2;
7588
7589 resultobj = SWIG_Py_Void();
7590 return resultobj;
7591 fail:
7592 return NULL;
7593 }
7594
7595
7596 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7597 PyObject *resultobj = 0;
7598 wxRect *arg1 = (wxRect *) 0 ;
7599 int result;
7600 void *argp1 = 0 ;
7601 int res1 = 0 ;
7602 PyObject *swig_obj[1] ;
7603
7604 if (!args) SWIG_fail;
7605 swig_obj[0] = args;
7606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7607 if (!SWIG_IsOK(res1)) {
7608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7609 }
7610 arg1 = reinterpret_cast< wxRect * >(argp1);
7611 result = (int) ((arg1)->y);
7612 resultobj = SWIG_From_int(static_cast< int >(result));
7613 return resultobj;
7614 fail:
7615 return NULL;
7616 }
7617
7618
7619 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7620 PyObject *resultobj = 0;
7621 wxRect *arg1 = (wxRect *) 0 ;
7622 int arg2 ;
7623 void *argp1 = 0 ;
7624 int res1 = 0 ;
7625 int val2 ;
7626 int ecode2 = 0 ;
7627 PyObject *swig_obj[2] ;
7628
7629 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7631 if (!SWIG_IsOK(res1)) {
7632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7633 }
7634 arg1 = reinterpret_cast< wxRect * >(argp1);
7635 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7636 if (!SWIG_IsOK(ecode2)) {
7637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7638 }
7639 arg2 = static_cast< int >(val2);
7640 if (arg1) (arg1)->width = arg2;
7641
7642 resultobj = SWIG_Py_Void();
7643 return resultobj;
7644 fail:
7645 return NULL;
7646 }
7647
7648
7649 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7650 PyObject *resultobj = 0;
7651 wxRect *arg1 = (wxRect *) 0 ;
7652 int result;
7653 void *argp1 = 0 ;
7654 int res1 = 0 ;
7655 PyObject *swig_obj[1] ;
7656
7657 if (!args) SWIG_fail;
7658 swig_obj[0] = args;
7659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7660 if (!SWIG_IsOK(res1)) {
7661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7662 }
7663 arg1 = reinterpret_cast< wxRect * >(argp1);
7664 result = (int) ((arg1)->width);
7665 resultobj = SWIG_From_int(static_cast< int >(result));
7666 return resultobj;
7667 fail:
7668 return NULL;
7669 }
7670
7671
7672 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7673 PyObject *resultobj = 0;
7674 wxRect *arg1 = (wxRect *) 0 ;
7675 int arg2 ;
7676 void *argp1 = 0 ;
7677 int res1 = 0 ;
7678 int val2 ;
7679 int ecode2 = 0 ;
7680 PyObject *swig_obj[2] ;
7681
7682 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7684 if (!SWIG_IsOK(res1)) {
7685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7686 }
7687 arg1 = reinterpret_cast< wxRect * >(argp1);
7688 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7689 if (!SWIG_IsOK(ecode2)) {
7690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7691 }
7692 arg2 = static_cast< int >(val2);
7693 if (arg1) (arg1)->height = arg2;
7694
7695 resultobj = SWIG_Py_Void();
7696 return resultobj;
7697 fail:
7698 return NULL;
7699 }
7700
7701
7702 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7703 PyObject *resultobj = 0;
7704 wxRect *arg1 = (wxRect *) 0 ;
7705 int result;
7706 void *argp1 = 0 ;
7707 int res1 = 0 ;
7708 PyObject *swig_obj[1] ;
7709
7710 if (!args) SWIG_fail;
7711 swig_obj[0] = args;
7712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7713 if (!SWIG_IsOK(res1)) {
7714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7715 }
7716 arg1 = reinterpret_cast< wxRect * >(argp1);
7717 result = (int) ((arg1)->height);
7718 resultobj = SWIG_From_int(static_cast< int >(result));
7719 return resultobj;
7720 fail:
7721 return NULL;
7722 }
7723
7724
7725 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7726 PyObject *resultobj = 0;
7727 wxRect *arg1 = (wxRect *) 0 ;
7728 int arg2 = (int) 0 ;
7729 int arg3 = (int) 0 ;
7730 int arg4 = (int) 0 ;
7731 int arg5 = (int) 0 ;
7732 void *argp1 = 0 ;
7733 int res1 = 0 ;
7734 int val2 ;
7735 int ecode2 = 0 ;
7736 int val3 ;
7737 int ecode3 = 0 ;
7738 int val4 ;
7739 int ecode4 = 0 ;
7740 int val5 ;
7741 int ecode5 = 0 ;
7742 PyObject * obj0 = 0 ;
7743 PyObject * obj1 = 0 ;
7744 PyObject * obj2 = 0 ;
7745 PyObject * obj3 = 0 ;
7746 PyObject * obj4 = 0 ;
7747 char * kwnames[] = {
7748 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7749 };
7750
7751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7753 if (!SWIG_IsOK(res1)) {
7754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7755 }
7756 arg1 = reinterpret_cast< wxRect * >(argp1);
7757 if (obj1) {
7758 ecode2 = SWIG_AsVal_int(obj1, &val2);
7759 if (!SWIG_IsOK(ecode2)) {
7760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7761 }
7762 arg2 = static_cast< int >(val2);
7763 }
7764 if (obj2) {
7765 ecode3 = SWIG_AsVal_int(obj2, &val3);
7766 if (!SWIG_IsOK(ecode3)) {
7767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7768 }
7769 arg3 = static_cast< int >(val3);
7770 }
7771 if (obj3) {
7772 ecode4 = SWIG_AsVal_int(obj3, &val4);
7773 if (!SWIG_IsOK(ecode4)) {
7774 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7775 }
7776 arg4 = static_cast< int >(val4);
7777 }
7778 if (obj4) {
7779 ecode5 = SWIG_AsVal_int(obj4, &val5);
7780 if (!SWIG_IsOK(ecode5)) {
7781 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7782 }
7783 arg5 = static_cast< int >(val5);
7784 }
7785 {
7786 PyThreadState* __tstate = wxPyBeginAllowThreads();
7787 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7788 wxPyEndAllowThreads(__tstate);
7789 if (PyErr_Occurred()) SWIG_fail;
7790 }
7791 resultobj = SWIG_Py_Void();
7792 return resultobj;
7793 fail:
7794 return NULL;
7795 }
7796
7797
7798 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7799 PyObject *resultobj = 0;
7800 wxRect *arg1 = (wxRect *) 0 ;
7801 PyObject *result = 0 ;
7802 void *argp1 = 0 ;
7803 int res1 = 0 ;
7804 PyObject *swig_obj[1] ;
7805
7806 if (!args) SWIG_fail;
7807 swig_obj[0] = args;
7808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7809 if (!SWIG_IsOK(res1)) {
7810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7811 }
7812 arg1 = reinterpret_cast< wxRect * >(argp1);
7813 {
7814 PyThreadState* __tstate = wxPyBeginAllowThreads();
7815 result = (PyObject *)wxRect_Get(arg1);
7816 wxPyEndAllowThreads(__tstate);
7817 if (PyErr_Occurred()) SWIG_fail;
7818 }
7819 resultobj = result;
7820 return resultobj;
7821 fail:
7822 return NULL;
7823 }
7824
7825
7826 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7827 PyObject *obj;
7828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7829 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7830 return SWIG_Py_Void();
7831 }
7832
7833 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7834 return SWIG_Python_InitShadowInstance(args);
7835 }
7836
7837 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7838 PyObject *resultobj = 0;
7839 wxRect *arg1 = (wxRect *) 0 ;
7840 wxRect *arg2 = (wxRect *) 0 ;
7841 PyObject *result = 0 ;
7842 void *argp1 = 0 ;
7843 int res1 = 0 ;
7844 void *argp2 = 0 ;
7845 int res2 = 0 ;
7846 PyObject * obj0 = 0 ;
7847 PyObject * obj1 = 0 ;
7848 char * kwnames[] = {
7849 (char *) "r1",(char *) "r2", NULL
7850 };
7851
7852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7854 if (!SWIG_IsOK(res1)) {
7855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7856 }
7857 arg1 = reinterpret_cast< wxRect * >(argp1);
7858 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7859 if (!SWIG_IsOK(res2)) {
7860 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7861 }
7862 arg2 = reinterpret_cast< wxRect * >(argp2);
7863 {
7864 if (!wxPyCheckForApp()) SWIG_fail;
7865 PyThreadState* __tstate = wxPyBeginAllowThreads();
7866 result = (PyObject *)wxIntersectRect(arg1,arg2);
7867 wxPyEndAllowThreads(__tstate);
7868 if (PyErr_Occurred()) SWIG_fail;
7869 }
7870 resultobj = result;
7871 return resultobj;
7872 fail:
7873 return NULL;
7874 }
7875
7876
7877 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7878 PyObject *resultobj = 0;
7879 double arg1 = (double) 0.0 ;
7880 double arg2 = (double) 0.0 ;
7881 wxPoint2D *result = 0 ;
7882 double val1 ;
7883 int ecode1 = 0 ;
7884 double val2 ;
7885 int ecode2 = 0 ;
7886 PyObject * obj0 = 0 ;
7887 PyObject * obj1 = 0 ;
7888 char * kwnames[] = {
7889 (char *) "x",(char *) "y", NULL
7890 };
7891
7892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7893 if (obj0) {
7894 ecode1 = SWIG_AsVal_double(obj0, &val1);
7895 if (!SWIG_IsOK(ecode1)) {
7896 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7897 }
7898 arg1 = static_cast< double >(val1);
7899 }
7900 if (obj1) {
7901 ecode2 = SWIG_AsVal_double(obj1, &val2);
7902 if (!SWIG_IsOK(ecode2)) {
7903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7904 }
7905 arg2 = static_cast< double >(val2);
7906 }
7907 {
7908 PyThreadState* __tstate = wxPyBeginAllowThreads();
7909 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7910 wxPyEndAllowThreads(__tstate);
7911 if (PyErr_Occurred()) SWIG_fail;
7912 }
7913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7914 return resultobj;
7915 fail:
7916 return NULL;
7917 }
7918
7919
7920 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7921 PyObject *resultobj = 0;
7922 wxPoint2D *arg1 = 0 ;
7923 wxPoint2D *result = 0 ;
7924 wxPoint2D temp1 ;
7925 PyObject * obj0 = 0 ;
7926 char * kwnames[] = {
7927 (char *) "pt", NULL
7928 };
7929
7930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
7931 {
7932 arg1 = &temp1;
7933 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
7934 }
7935 {
7936 PyThreadState* __tstate = wxPyBeginAllowThreads();
7937 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
7938 wxPyEndAllowThreads(__tstate);
7939 if (PyErr_Occurred()) SWIG_fail;
7940 }
7941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
7942 return resultobj;
7943 fail:
7944 return NULL;
7945 }
7946
7947
7948 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7949 PyObject *resultobj = 0;
7950 wxPoint *arg1 = 0 ;
7951 wxPoint2D *result = 0 ;
7952 wxPoint temp1 ;
7953 PyObject * obj0 = 0 ;
7954 char * kwnames[] = {
7955 (char *) "pt", NULL
7956 };
7957
7958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
7959 {
7960 arg1 = &temp1;
7961 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7962 }
7963 {
7964 PyThreadState* __tstate = wxPyBeginAllowThreads();
7965 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
7966 wxPyEndAllowThreads(__tstate);
7967 if (PyErr_Occurred()) SWIG_fail;
7968 }
7969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
7970 return resultobj;
7971 fail:
7972 return NULL;
7973 }
7974
7975
7976 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7977 PyObject *resultobj = 0;
7978 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7979 int *arg2 = (int *) 0 ;
7980 int *arg3 = (int *) 0 ;
7981 void *argp1 = 0 ;
7982 int res1 = 0 ;
7983 int temp2 ;
7984 int res2 = SWIG_TMPOBJ ;
7985 int temp3 ;
7986 int res3 = SWIG_TMPOBJ ;
7987 PyObject *swig_obj[1] ;
7988
7989 arg2 = &temp2;
7990 arg3 = &temp3;
7991 if (!args) SWIG_fail;
7992 swig_obj[0] = args;
7993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
7994 if (!SWIG_IsOK(res1)) {
7995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
7996 }
7997 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
7998 {
7999 PyThreadState* __tstate = wxPyBeginAllowThreads();
8000 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8001 wxPyEndAllowThreads(__tstate);
8002 if (PyErr_Occurred()) SWIG_fail;
8003 }
8004 resultobj = SWIG_Py_Void();
8005 if (SWIG_IsTmpObj(res2)) {
8006 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8007 } else {
8008 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8009 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8010 }
8011 if (SWIG_IsTmpObj(res3)) {
8012 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8013 } else {
8014 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8015 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8016 }
8017 return resultobj;
8018 fail:
8019 return NULL;
8020 }
8021
8022
8023 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8024 PyObject *resultobj = 0;
8025 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8026 int *arg2 = (int *) 0 ;
8027 int *arg3 = (int *) 0 ;
8028 void *argp1 = 0 ;
8029 int res1 = 0 ;
8030 int temp2 ;
8031 int res2 = SWIG_TMPOBJ ;
8032 int temp3 ;
8033 int res3 = SWIG_TMPOBJ ;
8034 PyObject *swig_obj[1] ;
8035
8036 arg2 = &temp2;
8037 arg3 = &temp3;
8038 if (!args) SWIG_fail;
8039 swig_obj[0] = args;
8040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8041 if (!SWIG_IsOK(res1)) {
8042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8043 }
8044 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8045 {
8046 PyThreadState* __tstate = wxPyBeginAllowThreads();
8047 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8048 wxPyEndAllowThreads(__tstate);
8049 if (PyErr_Occurred()) SWIG_fail;
8050 }
8051 resultobj = SWIG_Py_Void();
8052 if (SWIG_IsTmpObj(res2)) {
8053 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8054 } else {
8055 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8056 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8057 }
8058 if (SWIG_IsTmpObj(res3)) {
8059 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8060 } else {
8061 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8062 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8063 }
8064 return resultobj;
8065 fail:
8066 return NULL;
8067 }
8068
8069
8070 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8071 PyObject *resultobj = 0;
8072 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8073 double result;
8074 void *argp1 = 0 ;
8075 int res1 = 0 ;
8076 PyObject *swig_obj[1] ;
8077
8078 if (!args) SWIG_fail;
8079 swig_obj[0] = args;
8080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8081 if (!SWIG_IsOK(res1)) {
8082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8083 }
8084 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8085 {
8086 PyThreadState* __tstate = wxPyBeginAllowThreads();
8087 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8088 wxPyEndAllowThreads(__tstate);
8089 if (PyErr_Occurred()) SWIG_fail;
8090 }
8091 resultobj = SWIG_From_double(static_cast< double >(result));
8092 return resultobj;
8093 fail:
8094 return NULL;
8095 }
8096
8097
8098 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8099 PyObject *resultobj = 0;
8100 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8101 double result;
8102 void *argp1 = 0 ;
8103 int res1 = 0 ;
8104 PyObject *swig_obj[1] ;
8105
8106 if (!args) SWIG_fail;
8107 swig_obj[0] = args;
8108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8109 if (!SWIG_IsOK(res1)) {
8110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8111 }
8112 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8113 {
8114 PyThreadState* __tstate = wxPyBeginAllowThreads();
8115 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8116 wxPyEndAllowThreads(__tstate);
8117 if (PyErr_Occurred()) SWIG_fail;
8118 }
8119 resultobj = SWIG_From_double(static_cast< double >(result));
8120 return resultobj;
8121 fail:
8122 return NULL;
8123 }
8124
8125
8126 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8127 PyObject *resultobj = 0;
8128 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8129 double arg2 ;
8130 void *argp1 = 0 ;
8131 int res1 = 0 ;
8132 double val2 ;
8133 int ecode2 = 0 ;
8134 PyObject * obj0 = 0 ;
8135 PyObject * obj1 = 0 ;
8136 char * kwnames[] = {
8137 (char *) "self",(char *) "length", NULL
8138 };
8139
8140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8142 if (!SWIG_IsOK(res1)) {
8143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8144 }
8145 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8146 ecode2 = SWIG_AsVal_double(obj1, &val2);
8147 if (!SWIG_IsOK(ecode2)) {
8148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8149 }
8150 arg2 = static_cast< double >(val2);
8151 {
8152 PyThreadState* __tstate = wxPyBeginAllowThreads();
8153 (arg1)->SetVectorLength(arg2);
8154 wxPyEndAllowThreads(__tstate);
8155 if (PyErr_Occurred()) SWIG_fail;
8156 }
8157 resultobj = SWIG_Py_Void();
8158 return resultobj;
8159 fail:
8160 return NULL;
8161 }
8162
8163
8164 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8165 PyObject *resultobj = 0;
8166 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8167 double arg2 ;
8168 void *argp1 = 0 ;
8169 int res1 = 0 ;
8170 double val2 ;
8171 int ecode2 = 0 ;
8172 PyObject * obj0 = 0 ;
8173 PyObject * obj1 = 0 ;
8174 char * kwnames[] = {
8175 (char *) "self",(char *) "degrees", NULL
8176 };
8177
8178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8180 if (!SWIG_IsOK(res1)) {
8181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8182 }
8183 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8184 ecode2 = SWIG_AsVal_double(obj1, &val2);
8185 if (!SWIG_IsOK(ecode2)) {
8186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8187 }
8188 arg2 = static_cast< double >(val2);
8189 {
8190 PyThreadState* __tstate = wxPyBeginAllowThreads();
8191 (arg1)->SetVectorAngle(arg2);
8192 wxPyEndAllowThreads(__tstate);
8193 if (PyErr_Occurred()) SWIG_fail;
8194 }
8195 resultobj = SWIG_Py_Void();
8196 return resultobj;
8197 fail:
8198 return NULL;
8199 }
8200
8201
8202 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8203 PyObject *resultobj = 0;
8204 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8205 wxPoint2D *arg2 = 0 ;
8206 double result;
8207 void *argp1 = 0 ;
8208 int res1 = 0 ;
8209 wxPoint2D temp2 ;
8210 PyObject * obj0 = 0 ;
8211 PyObject * obj1 = 0 ;
8212 char * kwnames[] = {
8213 (char *) "self",(char *) "pt", NULL
8214 };
8215
8216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8218 if (!SWIG_IsOK(res1)) {
8219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8220 }
8221 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8222 {
8223 arg2 = &temp2;
8224 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8225 }
8226 {
8227 PyThreadState* __tstate = wxPyBeginAllowThreads();
8228 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8229 wxPyEndAllowThreads(__tstate);
8230 if (PyErr_Occurred()) SWIG_fail;
8231 }
8232 resultobj = SWIG_From_double(static_cast< double >(result));
8233 return resultobj;
8234 fail:
8235 return NULL;
8236 }
8237
8238
8239 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8240 PyObject *resultobj = 0;
8241 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8242 wxPoint2D *arg2 = 0 ;
8243 double result;
8244 void *argp1 = 0 ;
8245 int res1 = 0 ;
8246 wxPoint2D temp2 ;
8247 PyObject * obj0 = 0 ;
8248 PyObject * obj1 = 0 ;
8249 char * kwnames[] = {
8250 (char *) "self",(char *) "pt", NULL
8251 };
8252
8253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8255 if (!SWIG_IsOK(res1)) {
8256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8257 }
8258 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8259 {
8260 arg2 = &temp2;
8261 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8262 }
8263 {
8264 PyThreadState* __tstate = wxPyBeginAllowThreads();
8265 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8266 wxPyEndAllowThreads(__tstate);
8267 if (PyErr_Occurred()) SWIG_fail;
8268 }
8269 resultobj = SWIG_From_double(static_cast< double >(result));
8270 return resultobj;
8271 fail:
8272 return NULL;
8273 }
8274
8275
8276 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8277 PyObject *resultobj = 0;
8278 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8279 wxPoint2D *arg2 = 0 ;
8280 double result;
8281 void *argp1 = 0 ;
8282 int res1 = 0 ;
8283 wxPoint2D temp2 ;
8284 PyObject * obj0 = 0 ;
8285 PyObject * obj1 = 0 ;
8286 char * kwnames[] = {
8287 (char *) "self",(char *) "vec", NULL
8288 };
8289
8290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8292 if (!SWIG_IsOK(res1)) {
8293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8294 }
8295 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8296 {
8297 arg2 = &temp2;
8298 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8299 }
8300 {
8301 PyThreadState* __tstate = wxPyBeginAllowThreads();
8302 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8303 wxPyEndAllowThreads(__tstate);
8304 if (PyErr_Occurred()) SWIG_fail;
8305 }
8306 resultobj = SWIG_From_double(static_cast< double >(result));
8307 return resultobj;
8308 fail:
8309 return NULL;
8310 }
8311
8312
8313 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8314 PyObject *resultobj = 0;
8315 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8316 wxPoint2D *arg2 = 0 ;
8317 double result;
8318 void *argp1 = 0 ;
8319 int res1 = 0 ;
8320 wxPoint2D temp2 ;
8321 PyObject * obj0 = 0 ;
8322 PyObject * obj1 = 0 ;
8323 char * kwnames[] = {
8324 (char *) "self",(char *) "vec", NULL
8325 };
8326
8327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8329 if (!SWIG_IsOK(res1)) {
8330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8331 }
8332 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8333 {
8334 arg2 = &temp2;
8335 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8336 }
8337 {
8338 PyThreadState* __tstate = wxPyBeginAllowThreads();
8339 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8340 wxPyEndAllowThreads(__tstate);
8341 if (PyErr_Occurred()) SWIG_fail;
8342 }
8343 resultobj = SWIG_From_double(static_cast< double >(result));
8344 return resultobj;
8345 fail:
8346 return NULL;
8347 }
8348
8349
8350 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8351 PyObject *resultobj = 0;
8352 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8353 wxPoint2D result;
8354 void *argp1 = 0 ;
8355 int res1 = 0 ;
8356 PyObject *swig_obj[1] ;
8357
8358 if (!args) SWIG_fail;
8359 swig_obj[0] = args;
8360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8361 if (!SWIG_IsOK(res1)) {
8362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8363 }
8364 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8365 {
8366 PyThreadState* __tstate = wxPyBeginAllowThreads();
8367 result = (arg1)->operator -();
8368 wxPyEndAllowThreads(__tstate);
8369 if (PyErr_Occurred()) SWIG_fail;
8370 }
8371 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8372 return resultobj;
8373 fail:
8374 return NULL;
8375 }
8376
8377
8378 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8379 PyObject *resultobj = 0;
8380 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8381 wxPoint2D *arg2 = 0 ;
8382 wxPoint2D *result = 0 ;
8383 void *argp1 = 0 ;
8384 int res1 = 0 ;
8385 wxPoint2D temp2 ;
8386 PyObject * obj0 = 0 ;
8387 PyObject * obj1 = 0 ;
8388 char * kwnames[] = {
8389 (char *) "self",(char *) "pt", NULL
8390 };
8391
8392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8394 if (!SWIG_IsOK(res1)) {
8395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8396 }
8397 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8398 {
8399 arg2 = &temp2;
8400 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8401 }
8402 {
8403 PyThreadState* __tstate = wxPyBeginAllowThreads();
8404 {
8405 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8406 result = (wxPoint2D *) &_result_ref;
8407 }
8408 wxPyEndAllowThreads(__tstate);
8409 if (PyErr_Occurred()) SWIG_fail;
8410 }
8411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8412 return resultobj;
8413 fail:
8414 return NULL;
8415 }
8416
8417
8418 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8419 PyObject *resultobj = 0;
8420 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8421 wxPoint2D *arg2 = 0 ;
8422 wxPoint2D *result = 0 ;
8423 void *argp1 = 0 ;
8424 int res1 = 0 ;
8425 wxPoint2D temp2 ;
8426 PyObject * obj0 = 0 ;
8427 PyObject * obj1 = 0 ;
8428 char * kwnames[] = {
8429 (char *) "self",(char *) "pt", NULL
8430 };
8431
8432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8434 if (!SWIG_IsOK(res1)) {
8435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8436 }
8437 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8438 {
8439 arg2 = &temp2;
8440 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8441 }
8442 {
8443 PyThreadState* __tstate = wxPyBeginAllowThreads();
8444 {
8445 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8446 result = (wxPoint2D *) &_result_ref;
8447 }
8448 wxPyEndAllowThreads(__tstate);
8449 if (PyErr_Occurred()) SWIG_fail;
8450 }
8451 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8452 return resultobj;
8453 fail:
8454 return NULL;
8455 }
8456
8457
8458 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8459 PyObject *resultobj = 0;
8460 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8461 wxPoint2D *arg2 = 0 ;
8462 wxPoint2D *result = 0 ;
8463 void *argp1 = 0 ;
8464 int res1 = 0 ;
8465 wxPoint2D temp2 ;
8466 PyObject * obj0 = 0 ;
8467 PyObject * obj1 = 0 ;
8468 char * kwnames[] = {
8469 (char *) "self",(char *) "pt", NULL
8470 };
8471
8472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8474 if (!SWIG_IsOK(res1)) {
8475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8476 }
8477 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8478 {
8479 arg2 = &temp2;
8480 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8481 }
8482 {
8483 PyThreadState* __tstate = wxPyBeginAllowThreads();
8484 {
8485 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8486 result = (wxPoint2D *) &_result_ref;
8487 }
8488 wxPyEndAllowThreads(__tstate);
8489 if (PyErr_Occurred()) SWIG_fail;
8490 }
8491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8492 return resultobj;
8493 fail:
8494 return NULL;
8495 }
8496
8497
8498 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8499 PyObject *resultobj = 0;
8500 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8501 wxPoint2D *arg2 = 0 ;
8502 wxPoint2D *result = 0 ;
8503 void *argp1 = 0 ;
8504 int res1 = 0 ;
8505 wxPoint2D temp2 ;
8506 PyObject * obj0 = 0 ;
8507 PyObject * obj1 = 0 ;
8508 char * kwnames[] = {
8509 (char *) "self",(char *) "pt", NULL
8510 };
8511
8512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8514 if (!SWIG_IsOK(res1)) {
8515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8516 }
8517 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8518 {
8519 arg2 = &temp2;
8520 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8521 }
8522 {
8523 PyThreadState* __tstate = wxPyBeginAllowThreads();
8524 {
8525 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8526 result = (wxPoint2D *) &_result_ref;
8527 }
8528 wxPyEndAllowThreads(__tstate);
8529 if (PyErr_Occurred()) SWIG_fail;
8530 }
8531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8532 return resultobj;
8533 fail:
8534 return NULL;
8535 }
8536
8537
8538 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8539 PyObject *resultobj = 0;
8540 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8541 wxPoint2D *arg2 = 0 ;
8542 bool result;
8543 void *argp1 = 0 ;
8544 int res1 = 0 ;
8545 wxPoint2D temp2 ;
8546 PyObject * obj0 = 0 ;
8547 PyObject * obj1 = 0 ;
8548 char * kwnames[] = {
8549 (char *) "self",(char *) "pt", NULL
8550 };
8551
8552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8554 if (!SWIG_IsOK(res1)) {
8555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8556 }
8557 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8558 {
8559 arg2 = &temp2;
8560 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8561 }
8562 {
8563 PyThreadState* __tstate = wxPyBeginAllowThreads();
8564 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
8565 wxPyEndAllowThreads(__tstate);
8566 if (PyErr_Occurred()) SWIG_fail;
8567 }
8568 {
8569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8570 }
8571 return resultobj;
8572 fail:
8573 return NULL;
8574 }
8575
8576
8577 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8578 PyObject *resultobj = 0;
8579 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8580 wxPoint2D *arg2 = 0 ;
8581 bool result;
8582 void *argp1 = 0 ;
8583 int res1 = 0 ;
8584 wxPoint2D temp2 ;
8585 PyObject * obj0 = 0 ;
8586 PyObject * obj1 = 0 ;
8587 char * kwnames[] = {
8588 (char *) "self",(char *) "pt", NULL
8589 };
8590
8591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8593 if (!SWIG_IsOK(res1)) {
8594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8595 }
8596 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8597 {
8598 arg2 = &temp2;
8599 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8600 }
8601 {
8602 PyThreadState* __tstate = wxPyBeginAllowThreads();
8603 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
8604 wxPyEndAllowThreads(__tstate);
8605 if (PyErr_Occurred()) SWIG_fail;
8606 }
8607 {
8608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8609 }
8610 return resultobj;
8611 fail:
8612 return NULL;
8613 }
8614
8615
8616 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8617 PyObject *resultobj = 0;
8618 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8619 double arg2 ;
8620 void *argp1 = 0 ;
8621 int res1 = 0 ;
8622 double val2 ;
8623 int ecode2 = 0 ;
8624 PyObject *swig_obj[2] ;
8625
8626 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8628 if (!SWIG_IsOK(res1)) {
8629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8630 }
8631 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8632 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8633 if (!SWIG_IsOK(ecode2)) {
8634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8635 }
8636 arg2 = static_cast< double >(val2);
8637 if (arg1) (arg1)->m_x = arg2;
8638
8639 resultobj = SWIG_Py_Void();
8640 return resultobj;
8641 fail:
8642 return NULL;
8643 }
8644
8645
8646 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8647 PyObject *resultobj = 0;
8648 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8649 double result;
8650 void *argp1 = 0 ;
8651 int res1 = 0 ;
8652 PyObject *swig_obj[1] ;
8653
8654 if (!args) SWIG_fail;
8655 swig_obj[0] = args;
8656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8657 if (!SWIG_IsOK(res1)) {
8658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8659 }
8660 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8661 result = (double) ((arg1)->m_x);
8662 resultobj = SWIG_From_double(static_cast< double >(result));
8663 return resultobj;
8664 fail:
8665 return NULL;
8666 }
8667
8668
8669 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8670 PyObject *resultobj = 0;
8671 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8672 double arg2 ;
8673 void *argp1 = 0 ;
8674 int res1 = 0 ;
8675 double val2 ;
8676 int ecode2 = 0 ;
8677 PyObject *swig_obj[2] ;
8678
8679 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8681 if (!SWIG_IsOK(res1)) {
8682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8683 }
8684 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8685 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8686 if (!SWIG_IsOK(ecode2)) {
8687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8688 }
8689 arg2 = static_cast< double >(val2);
8690 if (arg1) (arg1)->m_y = arg2;
8691
8692 resultobj = SWIG_Py_Void();
8693 return resultobj;
8694 fail:
8695 return NULL;
8696 }
8697
8698
8699 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8700 PyObject *resultobj = 0;
8701 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8702 double result;
8703 void *argp1 = 0 ;
8704 int res1 = 0 ;
8705 PyObject *swig_obj[1] ;
8706
8707 if (!args) SWIG_fail;
8708 swig_obj[0] = args;
8709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8710 if (!SWIG_IsOK(res1)) {
8711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8712 }
8713 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8714 result = (double) ((arg1)->m_y);
8715 resultobj = SWIG_From_double(static_cast< double >(result));
8716 return resultobj;
8717 fail:
8718 return NULL;
8719 }
8720
8721
8722 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8723 PyObject *resultobj = 0;
8724 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8725 double arg2 = (double) 0 ;
8726 double arg3 = (double) 0 ;
8727 void *argp1 = 0 ;
8728 int res1 = 0 ;
8729 double val2 ;
8730 int ecode2 = 0 ;
8731 double val3 ;
8732 int ecode3 = 0 ;
8733 PyObject * obj0 = 0 ;
8734 PyObject * obj1 = 0 ;
8735 PyObject * obj2 = 0 ;
8736 char * kwnames[] = {
8737 (char *) "self",(char *) "x",(char *) "y", NULL
8738 };
8739
8740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8742 if (!SWIG_IsOK(res1)) {
8743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8744 }
8745 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8746 if (obj1) {
8747 ecode2 = SWIG_AsVal_double(obj1, &val2);
8748 if (!SWIG_IsOK(ecode2)) {
8749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8750 }
8751 arg2 = static_cast< double >(val2);
8752 }
8753 if (obj2) {
8754 ecode3 = SWIG_AsVal_double(obj2, &val3);
8755 if (!SWIG_IsOK(ecode3)) {
8756 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8757 }
8758 arg3 = static_cast< double >(val3);
8759 }
8760 {
8761 PyThreadState* __tstate = wxPyBeginAllowThreads();
8762 wxPoint2D_Set(arg1,arg2,arg3);
8763 wxPyEndAllowThreads(__tstate);
8764 if (PyErr_Occurred()) SWIG_fail;
8765 }
8766 resultobj = SWIG_Py_Void();
8767 return resultobj;
8768 fail:
8769 return NULL;
8770 }
8771
8772
8773 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8774 PyObject *resultobj = 0;
8775 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8776 PyObject *result = 0 ;
8777 void *argp1 = 0 ;
8778 int res1 = 0 ;
8779 PyObject *swig_obj[1] ;
8780
8781 if (!args) SWIG_fail;
8782 swig_obj[0] = args;
8783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8784 if (!SWIG_IsOK(res1)) {
8785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8786 }
8787 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8788 {
8789 PyThreadState* __tstate = wxPyBeginAllowThreads();
8790 result = (PyObject *)wxPoint2D_Get(arg1);
8791 wxPyEndAllowThreads(__tstate);
8792 if (PyErr_Occurred()) SWIG_fail;
8793 }
8794 resultobj = result;
8795 return resultobj;
8796 fail:
8797 return NULL;
8798 }
8799
8800
8801 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8802 PyObject *obj;
8803 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8804 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8805 return SWIG_Py_Void();
8806 }
8807
8808 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8809 return SWIG_Python_InitShadowInstance(args);
8810 }
8811
8812 SWIGINTERN int DefaultPosition_set(PyObject *) {
8813 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8814 return 1;
8815 }
8816
8817
8818 SWIGINTERN PyObject *DefaultPosition_get(void) {
8819 PyObject *pyobj = 0;
8820
8821 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8822 return pyobj;
8823 }
8824
8825
8826 SWIGINTERN int DefaultSize_set(PyObject *) {
8827 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8828 return 1;
8829 }
8830
8831
8832 SWIGINTERN PyObject *DefaultSize_get(void) {
8833 PyObject *pyobj = 0;
8834
8835 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8836 return pyobj;
8837 }
8838
8839
8840 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8841 PyObject *resultobj = 0;
8842 PyObject *arg1 = (PyObject *) 0 ;
8843 wxPyInputStream *result = 0 ;
8844 PyObject * obj0 = 0 ;
8845 char * kwnames[] = {
8846 (char *) "p", NULL
8847 };
8848
8849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8850 arg1 = obj0;
8851 {
8852 PyThreadState* __tstate = wxPyBeginAllowThreads();
8853 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8854 wxPyEndAllowThreads(__tstate);
8855 if (PyErr_Occurred()) SWIG_fail;
8856 }
8857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8858 return resultobj;
8859 fail:
8860 return NULL;
8861 }
8862
8863
8864 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8865 PyObject *resultobj = 0;
8866 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8867 void *argp1 = 0 ;
8868 int res1 = 0 ;
8869 PyObject *swig_obj[1] ;
8870
8871 if (!args) SWIG_fail;
8872 swig_obj[0] = args;
8873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8874 if (!SWIG_IsOK(res1)) {
8875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8876 }
8877 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8878 {
8879 PyThreadState* __tstate = wxPyBeginAllowThreads();
8880 delete arg1;
8881
8882 wxPyEndAllowThreads(__tstate);
8883 if (PyErr_Occurred()) SWIG_fail;
8884 }
8885 resultobj = SWIG_Py_Void();
8886 return resultobj;
8887 fail:
8888 return NULL;
8889 }
8890
8891
8892 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8893 PyObject *resultobj = 0;
8894 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8895 void *argp1 = 0 ;
8896 int res1 = 0 ;
8897 PyObject *swig_obj[1] ;
8898
8899 if (!args) SWIG_fail;
8900 swig_obj[0] = args;
8901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8902 if (!SWIG_IsOK(res1)) {
8903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8904 }
8905 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8906 {
8907 PyThreadState* __tstate = wxPyBeginAllowThreads();
8908 (arg1)->close();
8909 wxPyEndAllowThreads(__tstate);
8910 if (PyErr_Occurred()) SWIG_fail;
8911 }
8912 resultobj = SWIG_Py_Void();
8913 return resultobj;
8914 fail:
8915 return NULL;
8916 }
8917
8918
8919 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8920 PyObject *resultobj = 0;
8921 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8922 void *argp1 = 0 ;
8923 int res1 = 0 ;
8924 PyObject *swig_obj[1] ;
8925
8926 if (!args) SWIG_fail;
8927 swig_obj[0] = args;
8928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8929 if (!SWIG_IsOK(res1)) {
8930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8931 }
8932 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8933 {
8934 PyThreadState* __tstate = wxPyBeginAllowThreads();
8935 (arg1)->flush();
8936 wxPyEndAllowThreads(__tstate);
8937 if (PyErr_Occurred()) SWIG_fail;
8938 }
8939 resultobj = SWIG_Py_Void();
8940 return resultobj;
8941 fail:
8942 return NULL;
8943 }
8944
8945
8946 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8947 PyObject *resultobj = 0;
8948 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8949 bool result;
8950 void *argp1 = 0 ;
8951 int res1 = 0 ;
8952 PyObject *swig_obj[1] ;
8953
8954 if (!args) SWIG_fail;
8955 swig_obj[0] = args;
8956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8957 if (!SWIG_IsOK(res1)) {
8958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8959 }
8960 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8961 {
8962 PyThreadState* __tstate = wxPyBeginAllowThreads();
8963 result = (bool)(arg1)->eof();
8964 wxPyEndAllowThreads(__tstate);
8965 if (PyErr_Occurred()) SWIG_fail;
8966 }
8967 {
8968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8969 }
8970 return resultobj;
8971 fail:
8972 return NULL;
8973 }
8974
8975
8976 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8977 PyObject *resultobj = 0;
8978 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8979 int arg2 = (int) -1 ;
8980 PyObject *result = 0 ;
8981 void *argp1 = 0 ;
8982 int res1 = 0 ;
8983 int val2 ;
8984 int ecode2 = 0 ;
8985 PyObject * obj0 = 0 ;
8986 PyObject * obj1 = 0 ;
8987 char * kwnames[] = {
8988 (char *) "self",(char *) "size", NULL
8989 };
8990
8991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
8992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8993 if (!SWIG_IsOK(res1)) {
8994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8995 }
8996 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8997 if (obj1) {
8998 ecode2 = SWIG_AsVal_int(obj1, &val2);
8999 if (!SWIG_IsOK(ecode2)) {
9000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9001 }
9002 arg2 = static_cast< int >(val2);
9003 }
9004 {
9005 PyThreadState* __tstate = wxPyBeginAllowThreads();
9006 result = (PyObject *)(arg1)->read(arg2);
9007 wxPyEndAllowThreads(__tstate);
9008 if (PyErr_Occurred()) SWIG_fail;
9009 }
9010 resultobj = result;
9011 return resultobj;
9012 fail:
9013 return NULL;
9014 }
9015
9016
9017 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9018 PyObject *resultobj = 0;
9019 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9020 int arg2 = (int) -1 ;
9021 PyObject *result = 0 ;
9022 void *argp1 = 0 ;
9023 int res1 = 0 ;
9024 int val2 ;
9025 int ecode2 = 0 ;
9026 PyObject * obj0 = 0 ;
9027 PyObject * obj1 = 0 ;
9028 char * kwnames[] = {
9029 (char *) "self",(char *) "size", NULL
9030 };
9031
9032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9034 if (!SWIG_IsOK(res1)) {
9035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9036 }
9037 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9038 if (obj1) {
9039 ecode2 = SWIG_AsVal_int(obj1, &val2);
9040 if (!SWIG_IsOK(ecode2)) {
9041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9042 }
9043 arg2 = static_cast< int >(val2);
9044 }
9045 {
9046 PyThreadState* __tstate = wxPyBeginAllowThreads();
9047 result = (PyObject *)(arg1)->readline(arg2);
9048 wxPyEndAllowThreads(__tstate);
9049 if (PyErr_Occurred()) SWIG_fail;
9050 }
9051 resultobj = result;
9052 return resultobj;
9053 fail:
9054 return NULL;
9055 }
9056
9057
9058 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9059 PyObject *resultobj = 0;
9060 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9061 int arg2 = (int) -1 ;
9062 PyObject *result = 0 ;
9063 void *argp1 = 0 ;
9064 int res1 = 0 ;
9065 int val2 ;
9066 int ecode2 = 0 ;
9067 PyObject * obj0 = 0 ;
9068 PyObject * obj1 = 0 ;
9069 char * kwnames[] = {
9070 (char *) "self",(char *) "sizehint", NULL
9071 };
9072
9073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9075 if (!SWIG_IsOK(res1)) {
9076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9077 }
9078 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9079 if (obj1) {
9080 ecode2 = SWIG_AsVal_int(obj1, &val2);
9081 if (!SWIG_IsOK(ecode2)) {
9082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9083 }
9084 arg2 = static_cast< int >(val2);
9085 }
9086 {
9087 PyThreadState* __tstate = wxPyBeginAllowThreads();
9088 result = (PyObject *)(arg1)->readlines(arg2);
9089 wxPyEndAllowThreads(__tstate);
9090 if (PyErr_Occurred()) SWIG_fail;
9091 }
9092 resultobj = result;
9093 return resultobj;
9094 fail:
9095 return NULL;
9096 }
9097
9098
9099 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9100 PyObject *resultobj = 0;
9101 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9102 int arg2 ;
9103 int arg3 = (int) 0 ;
9104 void *argp1 = 0 ;
9105 int res1 = 0 ;
9106 int val2 ;
9107 int ecode2 = 0 ;
9108 int val3 ;
9109 int ecode3 = 0 ;
9110 PyObject * obj0 = 0 ;
9111 PyObject * obj1 = 0 ;
9112 PyObject * obj2 = 0 ;
9113 char * kwnames[] = {
9114 (char *) "self",(char *) "offset",(char *) "whence", NULL
9115 };
9116
9117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9119 if (!SWIG_IsOK(res1)) {
9120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9121 }
9122 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9123 ecode2 = SWIG_AsVal_int(obj1, &val2);
9124 if (!SWIG_IsOK(ecode2)) {
9125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9126 }
9127 arg2 = static_cast< int >(val2);
9128 if (obj2) {
9129 ecode3 = SWIG_AsVal_int(obj2, &val3);
9130 if (!SWIG_IsOK(ecode3)) {
9131 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9132 }
9133 arg3 = static_cast< int >(val3);
9134 }
9135 {
9136 PyThreadState* __tstate = wxPyBeginAllowThreads();
9137 (arg1)->seek(arg2,arg3);
9138 wxPyEndAllowThreads(__tstate);
9139 if (PyErr_Occurred()) SWIG_fail;
9140 }
9141 resultobj = SWIG_Py_Void();
9142 return resultobj;
9143 fail:
9144 return NULL;
9145 }
9146
9147
9148 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9149 PyObject *resultobj = 0;
9150 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9151 int result;
9152 void *argp1 = 0 ;
9153 int res1 = 0 ;
9154 PyObject *swig_obj[1] ;
9155
9156 if (!args) SWIG_fail;
9157 swig_obj[0] = args;
9158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9159 if (!SWIG_IsOK(res1)) {
9160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9161 }
9162 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9163 {
9164 PyThreadState* __tstate = wxPyBeginAllowThreads();
9165 result = (int)(arg1)->tell();
9166 wxPyEndAllowThreads(__tstate);
9167 if (PyErr_Occurred()) SWIG_fail;
9168 }
9169 resultobj = SWIG_From_int(static_cast< int >(result));
9170 return resultobj;
9171 fail:
9172 return NULL;
9173 }
9174
9175
9176 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9177 PyObject *resultobj = 0;
9178 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9179 char result;
9180 void *argp1 = 0 ;
9181 int res1 = 0 ;
9182 PyObject *swig_obj[1] ;
9183
9184 if (!args) SWIG_fail;
9185 swig_obj[0] = args;
9186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9187 if (!SWIG_IsOK(res1)) {
9188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9189 }
9190 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9191 {
9192 PyThreadState* __tstate = wxPyBeginAllowThreads();
9193 result = (char)(arg1)->Peek();
9194 wxPyEndAllowThreads(__tstate);
9195 if (PyErr_Occurred()) SWIG_fail;
9196 }
9197 resultobj = SWIG_From_char(static_cast< char >(result));
9198 return resultobj;
9199 fail:
9200 return NULL;
9201 }
9202
9203
9204 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9205 PyObject *resultobj = 0;
9206 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9207 char result;
9208 void *argp1 = 0 ;
9209 int res1 = 0 ;
9210 PyObject *swig_obj[1] ;
9211
9212 if (!args) SWIG_fail;
9213 swig_obj[0] = args;
9214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9215 if (!SWIG_IsOK(res1)) {
9216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9217 }
9218 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9219 {
9220 PyThreadState* __tstate = wxPyBeginAllowThreads();
9221 result = (char)(arg1)->GetC();
9222 wxPyEndAllowThreads(__tstate);
9223 if (PyErr_Occurred()) SWIG_fail;
9224 }
9225 resultobj = SWIG_From_char(static_cast< char >(result));
9226 return resultobj;
9227 fail:
9228 return NULL;
9229 }
9230
9231
9232 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9233 PyObject *resultobj = 0;
9234 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9235 size_t result;
9236 void *argp1 = 0 ;
9237 int res1 = 0 ;
9238 PyObject *swig_obj[1] ;
9239
9240 if (!args) SWIG_fail;
9241 swig_obj[0] = args;
9242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9243 if (!SWIG_IsOK(res1)) {
9244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9245 }
9246 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9247 {
9248 PyThreadState* __tstate = wxPyBeginAllowThreads();
9249 result = (size_t)(arg1)->LastRead();
9250 wxPyEndAllowThreads(__tstate);
9251 if (PyErr_Occurred()) SWIG_fail;
9252 }
9253 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9254 return resultobj;
9255 fail:
9256 return NULL;
9257 }
9258
9259
9260 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9261 PyObject *resultobj = 0;
9262 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9263 bool result;
9264 void *argp1 = 0 ;
9265 int res1 = 0 ;
9266 PyObject *swig_obj[1] ;
9267
9268 if (!args) SWIG_fail;
9269 swig_obj[0] = args;
9270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9271 if (!SWIG_IsOK(res1)) {
9272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9273 }
9274 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9275 {
9276 PyThreadState* __tstate = wxPyBeginAllowThreads();
9277 result = (bool)(arg1)->CanRead();
9278 wxPyEndAllowThreads(__tstate);
9279 if (PyErr_Occurred()) SWIG_fail;
9280 }
9281 {
9282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9283 }
9284 return resultobj;
9285 fail:
9286 return NULL;
9287 }
9288
9289
9290 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9291 PyObject *resultobj = 0;
9292 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9293 bool result;
9294 void *argp1 = 0 ;
9295 int res1 = 0 ;
9296 PyObject *swig_obj[1] ;
9297
9298 if (!args) SWIG_fail;
9299 swig_obj[0] = args;
9300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9301 if (!SWIG_IsOK(res1)) {
9302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9303 }
9304 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9305 {
9306 PyThreadState* __tstate = wxPyBeginAllowThreads();
9307 result = (bool)(arg1)->Eof();
9308 wxPyEndAllowThreads(__tstate);
9309 if (PyErr_Occurred()) SWIG_fail;
9310 }
9311 {
9312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9313 }
9314 return resultobj;
9315 fail:
9316 return NULL;
9317 }
9318
9319
9320 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9321 PyObject *resultobj = 0;
9322 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9323 char arg2 ;
9324 bool result;
9325 void *argp1 = 0 ;
9326 int res1 = 0 ;
9327 char val2 ;
9328 int ecode2 = 0 ;
9329 PyObject * obj0 = 0 ;
9330 PyObject * obj1 = 0 ;
9331 char * kwnames[] = {
9332 (char *) "self",(char *) "c", NULL
9333 };
9334
9335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9337 if (!SWIG_IsOK(res1)) {
9338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9339 }
9340 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9341 ecode2 = SWIG_AsVal_char(obj1, &val2);
9342 if (!SWIG_IsOK(ecode2)) {
9343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9344 }
9345 arg2 = static_cast< char >(val2);
9346 {
9347 PyThreadState* __tstate = wxPyBeginAllowThreads();
9348 result = (bool)(arg1)->Ungetch(arg2);
9349 wxPyEndAllowThreads(__tstate);
9350 if (PyErr_Occurred()) SWIG_fail;
9351 }
9352 {
9353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9354 }
9355 return resultobj;
9356 fail:
9357 return NULL;
9358 }
9359
9360
9361 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9362 PyObject *resultobj = 0;
9363 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9364 long arg2 ;
9365 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9366 long result;
9367 void *argp1 = 0 ;
9368 int res1 = 0 ;
9369 long val2 ;
9370 int ecode2 = 0 ;
9371 int val3 ;
9372 int ecode3 = 0 ;
9373 PyObject * obj0 = 0 ;
9374 PyObject * obj1 = 0 ;
9375 PyObject * obj2 = 0 ;
9376 char * kwnames[] = {
9377 (char *) "self",(char *) "pos",(char *) "mode", NULL
9378 };
9379
9380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9382 if (!SWIG_IsOK(res1)) {
9383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9384 }
9385 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9386 ecode2 = SWIG_AsVal_long(obj1, &val2);
9387 if (!SWIG_IsOK(ecode2)) {
9388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9389 }
9390 arg2 = static_cast< long >(val2);
9391 if (obj2) {
9392 ecode3 = SWIG_AsVal_int(obj2, &val3);
9393 if (!SWIG_IsOK(ecode3)) {
9394 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9395 }
9396 arg3 = static_cast< wxSeekMode >(val3);
9397 }
9398 {
9399 PyThreadState* __tstate = wxPyBeginAllowThreads();
9400 result = (long)(arg1)->SeekI(arg2,arg3);
9401 wxPyEndAllowThreads(__tstate);
9402 if (PyErr_Occurred()) SWIG_fail;
9403 }
9404 resultobj = SWIG_From_long(static_cast< long >(result));
9405 return resultobj;
9406 fail:
9407 return NULL;
9408 }
9409
9410
9411 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9412 PyObject *resultobj = 0;
9413 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9414 long result;
9415 void *argp1 = 0 ;
9416 int res1 = 0 ;
9417 PyObject *swig_obj[1] ;
9418
9419 if (!args) SWIG_fail;
9420 swig_obj[0] = args;
9421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9422 if (!SWIG_IsOK(res1)) {
9423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9424 }
9425 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9426 {
9427 PyThreadState* __tstate = wxPyBeginAllowThreads();
9428 result = (long)(arg1)->TellI();
9429 wxPyEndAllowThreads(__tstate);
9430 if (PyErr_Occurred()) SWIG_fail;
9431 }
9432 resultobj = SWIG_From_long(static_cast< long >(result));
9433 return resultobj;
9434 fail:
9435 return NULL;
9436 }
9437
9438
9439 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9440 PyObject *obj;
9441 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9442 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9443 return SWIG_Py_Void();
9444 }
9445
9446 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9447 return SWIG_Python_InitShadowInstance(args);
9448 }
9449
9450 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9451 PyObject *resultobj = 0;
9452 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9453 PyObject *arg2 = (PyObject *) 0 ;
9454 void *argp1 = 0 ;
9455 int res1 = 0 ;
9456 PyObject * obj0 = 0 ;
9457 PyObject * obj1 = 0 ;
9458 char * kwnames[] = {
9459 (char *) "self",(char *) "obj", NULL
9460 };
9461
9462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9464 if (!SWIG_IsOK(res1)) {
9465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9466 }
9467 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9468 arg2 = obj1;
9469 {
9470 PyThreadState* __tstate = wxPyBeginAllowThreads();
9471 wxOutputStream_write(arg1,arg2);
9472 wxPyEndAllowThreads(__tstate);
9473 if (PyErr_Occurred()) SWIG_fail;
9474 }
9475 resultobj = SWIG_Py_Void();
9476 return resultobj;
9477 fail:
9478 return NULL;
9479 }
9480
9481
9482 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9483 PyObject *resultobj = 0;
9484 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9485 size_t result;
9486 void *argp1 = 0 ;
9487 int res1 = 0 ;
9488 PyObject *swig_obj[1] ;
9489
9490 if (!args) SWIG_fail;
9491 swig_obj[0] = args;
9492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9493 if (!SWIG_IsOK(res1)) {
9494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9495 }
9496 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9497 {
9498 PyThreadState* __tstate = wxPyBeginAllowThreads();
9499 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9500 wxPyEndAllowThreads(__tstate);
9501 if (PyErr_Occurred()) SWIG_fail;
9502 }
9503 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9504 return resultobj;
9505 fail:
9506 return NULL;
9507 }
9508
9509
9510 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9511 PyObject *obj;
9512 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9513 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9514 return SWIG_Py_Void();
9515 }
9516
9517 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9518 PyObject *resultobj = 0;
9519 wxInputStream *arg1 = (wxInputStream *) 0 ;
9520 wxString *arg2 = 0 ;
9521 wxString *arg3 = 0 ;
9522 wxString *arg4 = 0 ;
9523 wxDateTime arg5 ;
9524 wxFSFile *result = 0 ;
9525 wxPyInputStream *temp1 ;
9526 bool temp2 = false ;
9527 bool temp3 = false ;
9528 bool temp4 = false ;
9529 void *argp5 ;
9530 int res5 = 0 ;
9531 PyObject * obj0 = 0 ;
9532 PyObject * obj1 = 0 ;
9533 PyObject * obj2 = 0 ;
9534 PyObject * obj3 = 0 ;
9535 PyObject * obj4 = 0 ;
9536 char * kwnames[] = {
9537 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9538 };
9539
9540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9541 {
9542 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9543 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9544 } else {
9545 PyErr_Clear(); // clear the failure of the wxPyConvert above
9546 arg1 = wxPyCBInputStream_create(obj0, true);
9547 if (arg1 == NULL) {
9548 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9549 SWIG_fail;
9550 }
9551 }
9552 }
9553 {
9554 arg2 = wxString_in_helper(obj1);
9555 if (arg2 == NULL) SWIG_fail;
9556 temp2 = true;
9557 }
9558 {
9559 arg3 = wxString_in_helper(obj2);
9560 if (arg3 == NULL) SWIG_fail;
9561 temp3 = true;
9562 }
9563 {
9564 arg4 = wxString_in_helper(obj3);
9565 if (arg4 == NULL) SWIG_fail;
9566 temp4 = true;
9567 }
9568 {
9569 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9570 if (!SWIG_IsOK(res5)) {
9571 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9572 }
9573 if (!argp5) {
9574 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9575 } else {
9576 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9577 arg5 = *temp;
9578 if (SWIG_IsNewObj(res5)) delete temp;
9579 }
9580 }
9581 {
9582 PyThreadState* __tstate = wxPyBeginAllowThreads();
9583 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9584 wxPyEndAllowThreads(__tstate);
9585 if (PyErr_Occurred()) SWIG_fail;
9586 }
9587 {
9588 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9589 }
9590 {
9591 if (temp2)
9592 delete arg2;
9593 }
9594 {
9595 if (temp3)
9596 delete arg3;
9597 }
9598 {
9599 if (temp4)
9600 delete arg4;
9601 }
9602 return resultobj;
9603 fail:
9604 {
9605 if (temp2)
9606 delete arg2;
9607 }
9608 {
9609 if (temp3)
9610 delete arg3;
9611 }
9612 {
9613 if (temp4)
9614 delete arg4;
9615 }
9616 return NULL;
9617 }
9618
9619
9620 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9621 PyObject *resultobj = 0;
9622 wxFSFile *arg1 = (wxFSFile *) 0 ;
9623 void *argp1 = 0 ;
9624 int res1 = 0 ;
9625 PyObject *swig_obj[1] ;
9626
9627 if (!args) SWIG_fail;
9628 swig_obj[0] = args;
9629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9630 if (!SWIG_IsOK(res1)) {
9631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9632 }
9633 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9634 {
9635 PyThreadState* __tstate = wxPyBeginAllowThreads();
9636 delete arg1;
9637
9638 wxPyEndAllowThreads(__tstate);
9639 if (PyErr_Occurred()) SWIG_fail;
9640 }
9641 resultobj = SWIG_Py_Void();
9642 return resultobj;
9643 fail:
9644 return NULL;
9645 }
9646
9647
9648 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9649 PyObject *resultobj = 0;
9650 wxFSFile *arg1 = (wxFSFile *) 0 ;
9651 wxInputStream *result = 0 ;
9652 void *argp1 = 0 ;
9653 int res1 = 0 ;
9654 PyObject *swig_obj[1] ;
9655
9656 if (!args) SWIG_fail;
9657 swig_obj[0] = args;
9658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9659 if (!SWIG_IsOK(res1)) {
9660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9661 }
9662 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9663 {
9664 PyThreadState* __tstate = wxPyBeginAllowThreads();
9665 result = (wxInputStream *)(arg1)->GetStream();
9666 wxPyEndAllowThreads(__tstate);
9667 if (PyErr_Occurred()) SWIG_fail;
9668 }
9669 {
9670 wxPyInputStream * _ptr = NULL;
9671
9672 if (result) {
9673 _ptr = new wxPyInputStream(result);
9674 }
9675 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9676 }
9677 return resultobj;
9678 fail:
9679 return NULL;
9680 }
9681
9682
9683 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9684 PyObject *resultobj = 0;
9685 wxFSFile *arg1 = (wxFSFile *) 0 ;
9686 wxString *result = 0 ;
9687 void *argp1 = 0 ;
9688 int res1 = 0 ;
9689 PyObject *swig_obj[1] ;
9690
9691 if (!args) SWIG_fail;
9692 swig_obj[0] = args;
9693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9694 if (!SWIG_IsOK(res1)) {
9695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9696 }
9697 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9698 {
9699 PyThreadState* __tstate = wxPyBeginAllowThreads();
9700 {
9701 wxString const &_result_ref = (arg1)->GetMimeType();
9702 result = (wxString *) &_result_ref;
9703 }
9704 wxPyEndAllowThreads(__tstate);
9705 if (PyErr_Occurred()) SWIG_fail;
9706 }
9707 {
9708 #if wxUSE_UNICODE
9709 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9710 #else
9711 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9712 #endif
9713 }
9714 return resultobj;
9715 fail:
9716 return NULL;
9717 }
9718
9719
9720 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9721 PyObject *resultobj = 0;
9722 wxFSFile *arg1 = (wxFSFile *) 0 ;
9723 wxString *result = 0 ;
9724 void *argp1 = 0 ;
9725 int res1 = 0 ;
9726 PyObject *swig_obj[1] ;
9727
9728 if (!args) SWIG_fail;
9729 swig_obj[0] = args;
9730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9731 if (!SWIG_IsOK(res1)) {
9732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9733 }
9734 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9735 {
9736 PyThreadState* __tstate = wxPyBeginAllowThreads();
9737 {
9738 wxString const &_result_ref = (arg1)->GetLocation();
9739 result = (wxString *) &_result_ref;
9740 }
9741 wxPyEndAllowThreads(__tstate);
9742 if (PyErr_Occurred()) SWIG_fail;
9743 }
9744 {
9745 #if wxUSE_UNICODE
9746 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9747 #else
9748 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9749 #endif
9750 }
9751 return resultobj;
9752 fail:
9753 return NULL;
9754 }
9755
9756
9757 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9758 PyObject *resultobj = 0;
9759 wxFSFile *arg1 = (wxFSFile *) 0 ;
9760 wxString *result = 0 ;
9761 void *argp1 = 0 ;
9762 int res1 = 0 ;
9763 PyObject *swig_obj[1] ;
9764
9765 if (!args) SWIG_fail;
9766 swig_obj[0] = args;
9767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9768 if (!SWIG_IsOK(res1)) {
9769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9770 }
9771 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9772 {
9773 PyThreadState* __tstate = wxPyBeginAllowThreads();
9774 {
9775 wxString const &_result_ref = (arg1)->GetAnchor();
9776 result = (wxString *) &_result_ref;
9777 }
9778 wxPyEndAllowThreads(__tstate);
9779 if (PyErr_Occurred()) SWIG_fail;
9780 }
9781 {
9782 #if wxUSE_UNICODE
9783 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9784 #else
9785 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9786 #endif
9787 }
9788 return resultobj;
9789 fail:
9790 return NULL;
9791 }
9792
9793
9794 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9795 PyObject *resultobj = 0;
9796 wxFSFile *arg1 = (wxFSFile *) 0 ;
9797 wxDateTime result;
9798 void *argp1 = 0 ;
9799 int res1 = 0 ;
9800 PyObject *swig_obj[1] ;
9801
9802 if (!args) SWIG_fail;
9803 swig_obj[0] = args;
9804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9805 if (!SWIG_IsOK(res1)) {
9806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9807 }
9808 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9809 {
9810 PyThreadState* __tstate = wxPyBeginAllowThreads();
9811 result = (arg1)->GetModificationTime();
9812 wxPyEndAllowThreads(__tstate);
9813 if (PyErr_Occurred()) SWIG_fail;
9814 }
9815 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9816 return resultobj;
9817 fail:
9818 return NULL;
9819 }
9820
9821
9822 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9823 PyObject *obj;
9824 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9825 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9826 return SWIG_Py_Void();
9827 }
9828
9829 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9830 return SWIG_Python_InitShadowInstance(args);
9831 }
9832
9833 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9834 PyObject *obj;
9835 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9836 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9837 return SWIG_Py_Void();
9838 }
9839
9840 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9841 PyObject *resultobj = 0;
9842 wxPyFileSystemHandler *result = 0 ;
9843
9844 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9845 {
9846 PyThreadState* __tstate = wxPyBeginAllowThreads();
9847 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9848 wxPyEndAllowThreads(__tstate);
9849 if (PyErr_Occurred()) SWIG_fail;
9850 }
9851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9852 return resultobj;
9853 fail:
9854 return NULL;
9855 }
9856
9857
9858 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9859 PyObject *resultobj = 0;
9860 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9861 PyObject *arg2 = (PyObject *) 0 ;
9862 PyObject *arg3 = (PyObject *) 0 ;
9863 void *argp1 = 0 ;
9864 int res1 = 0 ;
9865 PyObject * obj0 = 0 ;
9866 PyObject * obj1 = 0 ;
9867 PyObject * obj2 = 0 ;
9868 char * kwnames[] = {
9869 (char *) "self",(char *) "self",(char *) "_class", NULL
9870 };
9871
9872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9874 if (!SWIG_IsOK(res1)) {
9875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9876 }
9877 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9878 arg2 = obj1;
9879 arg3 = obj2;
9880 {
9881 PyThreadState* __tstate = wxPyBeginAllowThreads();
9882 (arg1)->_setCallbackInfo(arg2,arg3);
9883 wxPyEndAllowThreads(__tstate);
9884 if (PyErr_Occurred()) SWIG_fail;
9885 }
9886 resultobj = SWIG_Py_Void();
9887 return resultobj;
9888 fail:
9889 return NULL;
9890 }
9891
9892
9893 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9894 PyObject *resultobj = 0;
9895 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9896 wxString *arg2 = 0 ;
9897 bool result;
9898 void *argp1 = 0 ;
9899 int res1 = 0 ;
9900 bool temp2 = false ;
9901 PyObject * obj0 = 0 ;
9902 PyObject * obj1 = 0 ;
9903 char * kwnames[] = {
9904 (char *) "self",(char *) "location", NULL
9905 };
9906
9907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
9908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9909 if (!SWIG_IsOK(res1)) {
9910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9911 }
9912 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9913 {
9914 arg2 = wxString_in_helper(obj1);
9915 if (arg2 == NULL) SWIG_fail;
9916 temp2 = true;
9917 }
9918 {
9919 PyThreadState* __tstate = wxPyBeginAllowThreads();
9920 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9921 wxPyEndAllowThreads(__tstate);
9922 if (PyErr_Occurred()) SWIG_fail;
9923 }
9924 {
9925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9926 }
9927 {
9928 if (temp2)
9929 delete arg2;
9930 }
9931 return resultobj;
9932 fail:
9933 {
9934 if (temp2)
9935 delete arg2;
9936 }
9937 return NULL;
9938 }
9939
9940
9941 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9942 PyObject *resultobj = 0;
9943 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9944 wxFileSystem *arg2 = 0 ;
9945 wxString *arg3 = 0 ;
9946 wxFSFile *result = 0 ;
9947 void *argp1 = 0 ;
9948 int res1 = 0 ;
9949 void *argp2 = 0 ;
9950 int res2 = 0 ;
9951 bool temp3 = false ;
9952 PyObject * obj0 = 0 ;
9953 PyObject * obj1 = 0 ;
9954 PyObject * obj2 = 0 ;
9955 char * kwnames[] = {
9956 (char *) "self",(char *) "fs",(char *) "location", NULL
9957 };
9958
9959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9961 if (!SWIG_IsOK(res1)) {
9962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9963 }
9964 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9965 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
9966 if (!SWIG_IsOK(res2)) {
9967 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
9968 }
9969 if (!argp2) {
9970 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
9971 }
9972 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
9973 {
9974 arg3 = wxString_in_helper(obj2);
9975 if (arg3 == NULL) SWIG_fail;
9976 temp3 = true;
9977 }
9978 {
9979 PyThreadState* __tstate = wxPyBeginAllowThreads();
9980 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9981 wxPyEndAllowThreads(__tstate);
9982 if (PyErr_Occurred()) SWIG_fail;
9983 }
9984 {
9985 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
9986 }
9987 {
9988 if (temp3)
9989 delete arg3;
9990 }
9991 return resultobj;
9992 fail:
9993 {
9994 if (temp3)
9995 delete arg3;
9996 }
9997 return NULL;
9998 }
9999
10000
10001 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10002 PyObject *resultobj = 0;
10003 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10004 wxString *arg2 = 0 ;
10005 int arg3 = (int) 0 ;
10006 wxString result;
10007 void *argp1 = 0 ;
10008 int res1 = 0 ;
10009 bool temp2 = false ;
10010 int val3 ;
10011 int ecode3 = 0 ;
10012 PyObject * obj0 = 0 ;
10013 PyObject * obj1 = 0 ;
10014 PyObject * obj2 = 0 ;
10015 char * kwnames[] = {
10016 (char *) "self",(char *) "spec",(char *) "flags", NULL
10017 };
10018
10019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10021 if (!SWIG_IsOK(res1)) {
10022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10023 }
10024 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10025 {
10026 arg2 = wxString_in_helper(obj1);
10027 if (arg2 == NULL) SWIG_fail;
10028 temp2 = true;
10029 }
10030 if (obj2) {
10031 ecode3 = SWIG_AsVal_int(obj2, &val3);
10032 if (!SWIG_IsOK(ecode3)) {
10033 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10034 }
10035 arg3 = static_cast< int >(val3);
10036 }
10037 {
10038 PyThreadState* __tstate = wxPyBeginAllowThreads();
10039 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10040 wxPyEndAllowThreads(__tstate);
10041 if (PyErr_Occurred()) SWIG_fail;
10042 }
10043 {
10044 #if wxUSE_UNICODE
10045 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10046 #else
10047 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10048 #endif
10049 }
10050 {
10051 if (temp2)
10052 delete arg2;
10053 }
10054 return resultobj;
10055 fail:
10056 {
10057 if (temp2)
10058 delete arg2;
10059 }
10060 return NULL;
10061 }
10062
10063
10064 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10065 PyObject *resultobj = 0;
10066 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10067 wxString result;
10068 void *argp1 = 0 ;
10069 int res1 = 0 ;
10070 PyObject *swig_obj[1] ;
10071
10072 if (!args) SWIG_fail;
10073 swig_obj[0] = args;
10074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10075 if (!SWIG_IsOK(res1)) {
10076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10077 }
10078 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10079 {
10080 PyThreadState* __tstate = wxPyBeginAllowThreads();
10081 result = (arg1)->FindNext();
10082 wxPyEndAllowThreads(__tstate);
10083 if (PyErr_Occurred()) SWIG_fail;
10084 }
10085 {
10086 #if wxUSE_UNICODE
10087 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10088 #else
10089 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10090 #endif
10091 }
10092 return resultobj;
10093 fail:
10094 return NULL;
10095 }
10096
10097
10098 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10099 PyObject *resultobj = 0;
10100 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10101 wxString *arg2 = 0 ;
10102 wxString result;
10103 void *argp1 = 0 ;
10104 int res1 = 0 ;
10105 bool temp2 = false ;
10106 PyObject * obj0 = 0 ;
10107 PyObject * obj1 = 0 ;
10108 char * kwnames[] = {
10109 (char *) "self",(char *) "location", NULL
10110 };
10111
10112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10114 if (!SWIG_IsOK(res1)) {
10115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10116 }
10117 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10118 {
10119 arg2 = wxString_in_helper(obj1);
10120 if (arg2 == NULL) SWIG_fail;
10121 temp2 = true;
10122 }
10123 {
10124 PyThreadState* __tstate = wxPyBeginAllowThreads();
10125 result = (arg1)->GetProtocol((wxString const &)*arg2);
10126 wxPyEndAllowThreads(__tstate);
10127 if (PyErr_Occurred()) SWIG_fail;
10128 }
10129 {
10130 #if wxUSE_UNICODE
10131 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10132 #else
10133 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10134 #endif
10135 }
10136 {
10137 if (temp2)
10138 delete arg2;
10139 }
10140 return resultobj;
10141 fail:
10142 {
10143 if (temp2)
10144 delete arg2;
10145 }
10146 return NULL;
10147 }
10148
10149
10150 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10151 PyObject *resultobj = 0;
10152 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10153 wxString *arg2 = 0 ;
10154 wxString result;
10155 void *argp1 = 0 ;
10156 int res1 = 0 ;
10157 bool temp2 = false ;
10158 PyObject * obj0 = 0 ;
10159 PyObject * obj1 = 0 ;
10160 char * kwnames[] = {
10161 (char *) "self",(char *) "location", NULL
10162 };
10163
10164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10166 if (!SWIG_IsOK(res1)) {
10167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10168 }
10169 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10170 {
10171 arg2 = wxString_in_helper(obj1);
10172 if (arg2 == NULL) SWIG_fail;
10173 temp2 = true;
10174 }
10175 {
10176 PyThreadState* __tstate = wxPyBeginAllowThreads();
10177 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10178 wxPyEndAllowThreads(__tstate);
10179 if (PyErr_Occurred()) SWIG_fail;
10180 }
10181 {
10182 #if wxUSE_UNICODE
10183 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10184 #else
10185 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10186 #endif
10187 }
10188 {
10189 if (temp2)
10190 delete arg2;
10191 }
10192 return resultobj;
10193 fail:
10194 {
10195 if (temp2)
10196 delete arg2;
10197 }
10198 return NULL;
10199 }
10200
10201
10202 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10203 PyObject *resultobj = 0;
10204 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10205 wxString *arg2 = 0 ;
10206 wxString result;
10207 void *argp1 = 0 ;
10208 int res1 = 0 ;
10209 bool temp2 = false ;
10210 PyObject * obj0 = 0 ;
10211 PyObject * obj1 = 0 ;
10212 char * kwnames[] = {
10213 (char *) "self",(char *) "location", NULL
10214 };
10215
10216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10218 if (!SWIG_IsOK(res1)) {
10219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10220 }
10221 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10222 {
10223 arg2 = wxString_in_helper(obj1);
10224 if (arg2 == NULL) SWIG_fail;
10225 temp2 = true;
10226 }
10227 {
10228 PyThreadState* __tstate = wxPyBeginAllowThreads();
10229 result = (arg1)->GetAnchor((wxString const &)*arg2);
10230 wxPyEndAllowThreads(__tstate);
10231 if (PyErr_Occurred()) SWIG_fail;
10232 }
10233 {
10234 #if wxUSE_UNICODE
10235 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10236 #else
10237 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10238 #endif
10239 }
10240 {
10241 if (temp2)
10242 delete arg2;
10243 }
10244 return resultobj;
10245 fail:
10246 {
10247 if (temp2)
10248 delete arg2;
10249 }
10250 return NULL;
10251 }
10252
10253
10254 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10255 PyObject *resultobj = 0;
10256 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10257 wxString *arg2 = 0 ;
10258 wxString result;
10259 void *argp1 = 0 ;
10260 int res1 = 0 ;
10261 bool temp2 = false ;
10262 PyObject * obj0 = 0 ;
10263 PyObject * obj1 = 0 ;
10264 char * kwnames[] = {
10265 (char *) "self",(char *) "location", NULL
10266 };
10267
10268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10270 if (!SWIG_IsOK(res1)) {
10271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10272 }
10273 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10274 {
10275 arg2 = wxString_in_helper(obj1);
10276 if (arg2 == NULL) SWIG_fail;
10277 temp2 = true;
10278 }
10279 {
10280 PyThreadState* __tstate = wxPyBeginAllowThreads();
10281 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10282 wxPyEndAllowThreads(__tstate);
10283 if (PyErr_Occurred()) SWIG_fail;
10284 }
10285 {
10286 #if wxUSE_UNICODE
10287 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10288 #else
10289 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10290 #endif
10291 }
10292 {
10293 if (temp2)
10294 delete arg2;
10295 }
10296 return resultobj;
10297 fail:
10298 {
10299 if (temp2)
10300 delete arg2;
10301 }
10302 return NULL;
10303 }
10304
10305
10306 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10307 PyObject *resultobj = 0;
10308 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10309 wxString *arg2 = 0 ;
10310 wxString result;
10311 void *argp1 = 0 ;
10312 int res1 = 0 ;
10313 bool temp2 = false ;
10314 PyObject * obj0 = 0 ;
10315 PyObject * obj1 = 0 ;
10316 char * kwnames[] = {
10317 (char *) "self",(char *) "location", NULL
10318 };
10319
10320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10322 if (!SWIG_IsOK(res1)) {
10323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10324 }
10325 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10326 {
10327 arg2 = wxString_in_helper(obj1);
10328 if (arg2 == NULL) SWIG_fail;
10329 temp2 = true;
10330 }
10331 {
10332 PyThreadState* __tstate = wxPyBeginAllowThreads();
10333 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10334 wxPyEndAllowThreads(__tstate);
10335 if (PyErr_Occurred()) SWIG_fail;
10336 }
10337 {
10338 #if wxUSE_UNICODE
10339 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10340 #else
10341 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10342 #endif
10343 }
10344 {
10345 if (temp2)
10346 delete arg2;
10347 }
10348 return resultobj;
10349 fail:
10350 {
10351 if (temp2)
10352 delete arg2;
10353 }
10354 return NULL;
10355 }
10356
10357
10358 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10359 PyObject *obj;
10360 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10361 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10362 return SWIG_Py_Void();
10363 }
10364
10365 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10366 return SWIG_Python_InitShadowInstance(args);
10367 }
10368
10369 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10370 PyObject *resultobj = 0;
10371 wxFileSystem *result = 0 ;
10372
10373 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10374 {
10375 PyThreadState* __tstate = wxPyBeginAllowThreads();
10376 result = (wxFileSystem *)new wxFileSystem();
10377 wxPyEndAllowThreads(__tstate);
10378 if (PyErr_Occurred()) SWIG_fail;
10379 }
10380 {
10381 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10382 }
10383 return resultobj;
10384 fail:
10385 return NULL;
10386 }
10387
10388
10389 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10390 PyObject *resultobj = 0;
10391 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10392 void *argp1 = 0 ;
10393 int res1 = 0 ;
10394 PyObject *swig_obj[1] ;
10395
10396 if (!args) SWIG_fail;
10397 swig_obj[0] = args;
10398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10399 if (!SWIG_IsOK(res1)) {
10400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10401 }
10402 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10403 {
10404 PyThreadState* __tstate = wxPyBeginAllowThreads();
10405 delete arg1;
10406
10407 wxPyEndAllowThreads(__tstate);
10408 if (PyErr_Occurred()) SWIG_fail;
10409 }
10410 resultobj = SWIG_Py_Void();
10411 return resultobj;
10412 fail:
10413 return NULL;
10414 }
10415
10416
10417 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10418 PyObject *resultobj = 0;
10419 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10420 wxString *arg2 = 0 ;
10421 bool arg3 = (bool) false ;
10422 void *argp1 = 0 ;
10423 int res1 = 0 ;
10424 bool temp2 = false ;
10425 bool val3 ;
10426 int ecode3 = 0 ;
10427 PyObject * obj0 = 0 ;
10428 PyObject * obj1 = 0 ;
10429 PyObject * obj2 = 0 ;
10430 char * kwnames[] = {
10431 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10432 };
10433
10434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10436 if (!SWIG_IsOK(res1)) {
10437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10438 }
10439 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10440 {
10441 arg2 = wxString_in_helper(obj1);
10442 if (arg2 == NULL) SWIG_fail;
10443 temp2 = true;
10444 }
10445 if (obj2) {
10446 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10447 if (!SWIG_IsOK(ecode3)) {
10448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10449 }
10450 arg3 = static_cast< bool >(val3);
10451 }
10452 {
10453 PyThreadState* __tstate = wxPyBeginAllowThreads();
10454 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10455 wxPyEndAllowThreads(__tstate);
10456 if (PyErr_Occurred()) SWIG_fail;
10457 }
10458 resultobj = SWIG_Py_Void();
10459 {
10460 if (temp2)
10461 delete arg2;
10462 }
10463 return resultobj;
10464 fail:
10465 {
10466 if (temp2)
10467 delete arg2;
10468 }
10469 return NULL;
10470 }
10471
10472
10473 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10474 PyObject *resultobj = 0;
10475 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10476 wxString result;
10477 void *argp1 = 0 ;
10478 int res1 = 0 ;
10479 PyObject *swig_obj[1] ;
10480
10481 if (!args) SWIG_fail;
10482 swig_obj[0] = args;
10483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10484 if (!SWIG_IsOK(res1)) {
10485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10486 }
10487 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10488 {
10489 PyThreadState* __tstate = wxPyBeginAllowThreads();
10490 result = (arg1)->GetPath();
10491 wxPyEndAllowThreads(__tstate);
10492 if (PyErr_Occurred()) SWIG_fail;
10493 }
10494 {
10495 #if wxUSE_UNICODE
10496 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10497 #else
10498 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10499 #endif
10500 }
10501 return resultobj;
10502 fail:
10503 return NULL;
10504 }
10505
10506
10507 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10508 PyObject *resultobj = 0;
10509 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10510 wxString *arg2 = 0 ;
10511 wxFSFile *result = 0 ;
10512 void *argp1 = 0 ;
10513 int res1 = 0 ;
10514 bool temp2 = false ;
10515 PyObject * obj0 = 0 ;
10516 PyObject * obj1 = 0 ;
10517 char * kwnames[] = {
10518 (char *) "self",(char *) "location", NULL
10519 };
10520
10521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10523 if (!SWIG_IsOK(res1)) {
10524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10525 }
10526 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10527 {
10528 arg2 = wxString_in_helper(obj1);
10529 if (arg2 == NULL) SWIG_fail;
10530 temp2 = true;
10531 }
10532 {
10533 PyThreadState* __tstate = wxPyBeginAllowThreads();
10534 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10535 wxPyEndAllowThreads(__tstate);
10536 if (PyErr_Occurred()) SWIG_fail;
10537 }
10538 {
10539 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10540 }
10541 {
10542 if (temp2)
10543 delete arg2;
10544 }
10545 return resultobj;
10546 fail:
10547 {
10548 if (temp2)
10549 delete arg2;
10550 }
10551 return NULL;
10552 }
10553
10554
10555 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10556 PyObject *resultobj = 0;
10557 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10558 wxString *arg2 = 0 ;
10559 int arg3 = (int) 0 ;
10560 wxString result;
10561 void *argp1 = 0 ;
10562 int res1 = 0 ;
10563 bool temp2 = false ;
10564 int val3 ;
10565 int ecode3 = 0 ;
10566 PyObject * obj0 = 0 ;
10567 PyObject * obj1 = 0 ;
10568 PyObject * obj2 = 0 ;
10569 char * kwnames[] = {
10570 (char *) "self",(char *) "spec",(char *) "flags", NULL
10571 };
10572
10573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10575 if (!SWIG_IsOK(res1)) {
10576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10577 }
10578 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10579 {
10580 arg2 = wxString_in_helper(obj1);
10581 if (arg2 == NULL) SWIG_fail;
10582 temp2 = true;
10583 }
10584 if (obj2) {
10585 ecode3 = SWIG_AsVal_int(obj2, &val3);
10586 if (!SWIG_IsOK(ecode3)) {
10587 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10588 }
10589 arg3 = static_cast< int >(val3);
10590 }
10591 {
10592 PyThreadState* __tstate = wxPyBeginAllowThreads();
10593 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10594 wxPyEndAllowThreads(__tstate);
10595 if (PyErr_Occurred()) SWIG_fail;
10596 }
10597 {
10598 #if wxUSE_UNICODE
10599 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10600 #else
10601 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10602 #endif
10603 }
10604 {
10605 if (temp2)
10606 delete arg2;
10607 }
10608 return resultobj;
10609 fail:
10610 {
10611 if (temp2)
10612 delete arg2;
10613 }
10614 return NULL;
10615 }
10616
10617
10618 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10619 PyObject *resultobj = 0;
10620 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10621 wxString result;
10622 void *argp1 = 0 ;
10623 int res1 = 0 ;
10624 PyObject *swig_obj[1] ;
10625
10626 if (!args) SWIG_fail;
10627 swig_obj[0] = args;
10628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10629 if (!SWIG_IsOK(res1)) {
10630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10631 }
10632 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10633 {
10634 PyThreadState* __tstate = wxPyBeginAllowThreads();
10635 result = (arg1)->FindNext();
10636 wxPyEndAllowThreads(__tstate);
10637 if (PyErr_Occurred()) SWIG_fail;
10638 }
10639 {
10640 #if wxUSE_UNICODE
10641 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10642 #else
10643 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10644 #endif
10645 }
10646 return resultobj;
10647 fail:
10648 return NULL;
10649 }
10650
10651
10652 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10653 PyObject *resultobj = 0;
10654 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10655 void *argp1 = 0 ;
10656 int res1 = 0 ;
10657 PyObject * obj0 = 0 ;
10658 char * kwnames[] = {
10659 (char *) "handler", NULL
10660 };
10661
10662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
10664 if (!SWIG_IsOK(res1)) {
10665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10666 }
10667 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10668 {
10669 PyThreadState* __tstate = wxPyBeginAllowThreads();
10670 wxFileSystem::AddHandler(arg1);
10671 wxPyEndAllowThreads(__tstate);
10672 if (PyErr_Occurred()) SWIG_fail;
10673 }
10674 resultobj = SWIG_Py_Void();
10675 return resultobj;
10676 fail:
10677 return NULL;
10678 }
10679
10680
10681 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10682 PyObject *resultobj = 0;
10683
10684 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10685 {
10686 PyThreadState* __tstate = wxPyBeginAllowThreads();
10687 wxFileSystem::CleanUpHandlers();
10688 wxPyEndAllowThreads(__tstate);
10689 if (PyErr_Occurred()) SWIG_fail;
10690 }
10691 resultobj = SWIG_Py_Void();
10692 return resultobj;
10693 fail:
10694 return NULL;
10695 }
10696
10697
10698 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10699 PyObject *resultobj = 0;
10700 wxString *arg1 = 0 ;
10701 wxString result;
10702 bool temp1 = false ;
10703 PyObject * obj0 = 0 ;
10704 char * kwnames[] = {
10705 (char *) "filename", NULL
10706 };
10707
10708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10709 {
10710 arg1 = wxString_in_helper(obj0);
10711 if (arg1 == NULL) SWIG_fail;
10712 temp1 = true;
10713 }
10714 {
10715 PyThreadState* __tstate = wxPyBeginAllowThreads();
10716 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10717 wxPyEndAllowThreads(__tstate);
10718 if (PyErr_Occurred()) SWIG_fail;
10719 }
10720 {
10721 #if wxUSE_UNICODE
10722 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10723 #else
10724 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10725 #endif
10726 }
10727 {
10728 if (temp1)
10729 delete arg1;
10730 }
10731 return resultobj;
10732 fail:
10733 {
10734 if (temp1)
10735 delete arg1;
10736 }
10737 return NULL;
10738 }
10739
10740
10741 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10742 PyObject *resultobj = 0;
10743 wxString *arg1 = 0 ;
10744 wxString result;
10745 bool temp1 = false ;
10746 PyObject * obj0 = 0 ;
10747 char * kwnames[] = {
10748 (char *) "url", NULL
10749 };
10750
10751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10752 {
10753 arg1 = wxString_in_helper(obj0);
10754 if (arg1 == NULL) SWIG_fail;
10755 temp1 = true;
10756 }
10757 {
10758 PyThreadState* __tstate = wxPyBeginAllowThreads();
10759 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10760 wxPyEndAllowThreads(__tstate);
10761 if (PyErr_Occurred()) SWIG_fail;
10762 }
10763 {
10764 #if wxUSE_UNICODE
10765 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10766 #else
10767 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10768 #endif
10769 }
10770 {
10771 if (temp1)
10772 delete arg1;
10773 }
10774 return resultobj;
10775 fail:
10776 {
10777 if (temp1)
10778 delete arg1;
10779 }
10780 return NULL;
10781 }
10782
10783
10784 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10785 PyObject *obj;
10786 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10787 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10788 return SWIG_Py_Void();
10789 }
10790
10791 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10792 return SWIG_Python_InitShadowInstance(args);
10793 }
10794
10795 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10796 PyObject *resultobj = 0;
10797 wxInternetFSHandler *result = 0 ;
10798
10799 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10800 {
10801 PyThreadState* __tstate = wxPyBeginAllowThreads();
10802 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10803 wxPyEndAllowThreads(__tstate);
10804 if (PyErr_Occurred()) SWIG_fail;
10805 }
10806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10807 return resultobj;
10808 fail:
10809 return NULL;
10810 }
10811
10812
10813 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10814 PyObject *resultobj = 0;
10815 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10816 wxString *arg2 = 0 ;
10817 bool result;
10818 void *argp1 = 0 ;
10819 int res1 = 0 ;
10820 bool temp2 = false ;
10821 PyObject * obj0 = 0 ;
10822 PyObject * obj1 = 0 ;
10823 char * kwnames[] = {
10824 (char *) "self",(char *) "location", NULL
10825 };
10826
10827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10829 if (!SWIG_IsOK(res1)) {
10830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10831 }
10832 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10833 {
10834 arg2 = wxString_in_helper(obj1);
10835 if (arg2 == NULL) SWIG_fail;
10836 temp2 = true;
10837 }
10838 {
10839 PyThreadState* __tstate = wxPyBeginAllowThreads();
10840 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10841 wxPyEndAllowThreads(__tstate);
10842 if (PyErr_Occurred()) SWIG_fail;
10843 }
10844 {
10845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10846 }
10847 {
10848 if (temp2)
10849 delete arg2;
10850 }
10851 return resultobj;
10852 fail:
10853 {
10854 if (temp2)
10855 delete arg2;
10856 }
10857 return NULL;
10858 }
10859
10860
10861 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10862 PyObject *resultobj = 0;
10863 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10864 wxFileSystem *arg2 = 0 ;
10865 wxString *arg3 = 0 ;
10866 wxFSFile *result = 0 ;
10867 void *argp1 = 0 ;
10868 int res1 = 0 ;
10869 void *argp2 = 0 ;
10870 int res2 = 0 ;
10871 bool temp3 = false ;
10872 PyObject * obj0 = 0 ;
10873 PyObject * obj1 = 0 ;
10874 PyObject * obj2 = 0 ;
10875 char * kwnames[] = {
10876 (char *) "self",(char *) "fs",(char *) "location", NULL
10877 };
10878
10879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10881 if (!SWIG_IsOK(res1)) {
10882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10883 }
10884 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10885 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10886 if (!SWIG_IsOK(res2)) {
10887 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10888 }
10889 if (!argp2) {
10890 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10891 }
10892 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10893 {
10894 arg3 = wxString_in_helper(obj2);
10895 if (arg3 == NULL) SWIG_fail;
10896 temp3 = true;
10897 }
10898 {
10899 PyThreadState* __tstate = wxPyBeginAllowThreads();
10900 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10901 wxPyEndAllowThreads(__tstate);
10902 if (PyErr_Occurred()) SWIG_fail;
10903 }
10904 {
10905 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10906 }
10907 {
10908 if (temp3)
10909 delete arg3;
10910 }
10911 return resultobj;
10912 fail:
10913 {
10914 if (temp3)
10915 delete arg3;
10916 }
10917 return NULL;
10918 }
10919
10920
10921 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10922 PyObject *obj;
10923 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10924 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
10925 return SWIG_Py_Void();
10926 }
10927
10928 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10929 return SWIG_Python_InitShadowInstance(args);
10930 }
10931
10932 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10933 PyObject *resultobj = 0;
10934 wxZipFSHandler *result = 0 ;
10935
10936 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
10937 {
10938 PyThreadState* __tstate = wxPyBeginAllowThreads();
10939 result = (wxZipFSHandler *)new wxZipFSHandler();
10940 wxPyEndAllowThreads(__tstate);
10941 if (PyErr_Occurred()) SWIG_fail;
10942 }
10943 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
10944 return resultobj;
10945 fail:
10946 return NULL;
10947 }
10948
10949
10950 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10951 PyObject *resultobj = 0;
10952 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
10953 wxString *arg2 = 0 ;
10954 bool result;
10955 void *argp1 = 0 ;
10956 int res1 = 0 ;
10957 bool temp2 = false ;
10958 PyObject * obj0 = 0 ;
10959 PyObject * obj1 = 0 ;
10960 char * kwnames[] = {
10961 (char *) "self",(char *) "location", NULL
10962 };
10963
10964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
10966 if (!SWIG_IsOK(res1)) {
10967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
10968 }
10969 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
10970 {
10971 arg2 = wxString_in_helper(obj1);
10972 if (arg2 == NULL) SWIG_fail;
10973 temp2 = true;
10974 }
10975 {
10976 PyThreadState* __tstate = wxPyBeginAllowThreads();
10977 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10978 wxPyEndAllowThreads(__tstate);
10979 if (PyErr_Occurred()) SWIG_fail;
10980 }
10981 {
10982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10983 }
10984 {
10985 if (temp2)
10986 delete arg2;
10987 }
10988 return resultobj;
10989 fail:
10990 {
10991 if (temp2)
10992 delete arg2;
10993 }
10994 return NULL;
10995 }
10996
10997
10998 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10999 PyObject *resultobj = 0;
11000 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11001 wxFileSystem *arg2 = 0 ;
11002 wxString *arg3 = 0 ;
11003 wxFSFile *result = 0 ;
11004 void *argp1 = 0 ;
11005 int res1 = 0 ;
11006 void *argp2 = 0 ;
11007 int res2 = 0 ;
11008 bool temp3 = false ;
11009 PyObject * obj0 = 0 ;
11010 PyObject * obj1 = 0 ;
11011 PyObject * obj2 = 0 ;
11012 char * kwnames[] = {
11013 (char *) "self",(char *) "fs",(char *) "location", NULL
11014 };
11015
11016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11018 if (!SWIG_IsOK(res1)) {
11019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11020 }
11021 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11022 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11023 if (!SWIG_IsOK(res2)) {
11024 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11025 }
11026 if (!argp2) {
11027 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11028 }
11029 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11030 {
11031 arg3 = wxString_in_helper(obj2);
11032 if (arg3 == NULL) SWIG_fail;
11033 temp3 = true;
11034 }
11035 {
11036 PyThreadState* __tstate = wxPyBeginAllowThreads();
11037 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11038 wxPyEndAllowThreads(__tstate);
11039 if (PyErr_Occurred()) SWIG_fail;
11040 }
11041 {
11042 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11043 }
11044 {
11045 if (temp3)
11046 delete arg3;
11047 }
11048 return resultobj;
11049 fail:
11050 {
11051 if (temp3)
11052 delete arg3;
11053 }
11054 return NULL;
11055 }
11056
11057
11058 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11059 PyObject *resultobj = 0;
11060 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11061 wxString *arg2 = 0 ;
11062 int arg3 = (int) 0 ;
11063 wxString result;
11064 void *argp1 = 0 ;
11065 int res1 = 0 ;
11066 bool temp2 = false ;
11067 int val3 ;
11068 int ecode3 = 0 ;
11069 PyObject * obj0 = 0 ;
11070 PyObject * obj1 = 0 ;
11071 PyObject * obj2 = 0 ;
11072 char * kwnames[] = {
11073 (char *) "self",(char *) "spec",(char *) "flags", NULL
11074 };
11075
11076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11078 if (!SWIG_IsOK(res1)) {
11079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11080 }
11081 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11082 {
11083 arg2 = wxString_in_helper(obj1);
11084 if (arg2 == NULL) SWIG_fail;
11085 temp2 = true;
11086 }
11087 if (obj2) {
11088 ecode3 = SWIG_AsVal_int(obj2, &val3);
11089 if (!SWIG_IsOK(ecode3)) {
11090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11091 }
11092 arg3 = static_cast< int >(val3);
11093 }
11094 {
11095 PyThreadState* __tstate = wxPyBeginAllowThreads();
11096 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11097 wxPyEndAllowThreads(__tstate);
11098 if (PyErr_Occurred()) SWIG_fail;
11099 }
11100 {
11101 #if wxUSE_UNICODE
11102 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11103 #else
11104 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11105 #endif
11106 }
11107 {
11108 if (temp2)
11109 delete arg2;
11110 }
11111 return resultobj;
11112 fail:
11113 {
11114 if (temp2)
11115 delete arg2;
11116 }
11117 return NULL;
11118 }
11119
11120
11121 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11122 PyObject *resultobj = 0;
11123 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11124 wxString result;
11125 void *argp1 = 0 ;
11126 int res1 = 0 ;
11127 PyObject *swig_obj[1] ;
11128
11129 if (!args) SWIG_fail;
11130 swig_obj[0] = args;
11131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11132 if (!SWIG_IsOK(res1)) {
11133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11134 }
11135 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11136 {
11137 PyThreadState* __tstate = wxPyBeginAllowThreads();
11138 result = (arg1)->FindNext();
11139 wxPyEndAllowThreads(__tstate);
11140 if (PyErr_Occurred()) SWIG_fail;
11141 }
11142 {
11143 #if wxUSE_UNICODE
11144 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11145 #else
11146 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11147 #endif
11148 }
11149 return resultobj;
11150 fail:
11151 return NULL;
11152 }
11153
11154
11155 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11156 PyObject *obj;
11157 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11158 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11159 return SWIG_Py_Void();
11160 }
11161
11162 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11163 return SWIG_Python_InitShadowInstance(args);
11164 }
11165
11166 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11167 PyObject *resultobj = 0;
11168 wxString *arg1 = 0 ;
11169 wxImage *arg2 = 0 ;
11170 long arg3 ;
11171 bool temp1 = false ;
11172 void *argp2 = 0 ;
11173 int res2 = 0 ;
11174 long val3 ;
11175 int ecode3 = 0 ;
11176 PyObject * obj0 = 0 ;
11177 PyObject * obj1 = 0 ;
11178 PyObject * obj2 = 0 ;
11179 char * kwnames[] = {
11180 (char *) "filename",(char *) "image",(char *) "type", NULL
11181 };
11182
11183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11184 {
11185 arg1 = wxString_in_helper(obj0);
11186 if (arg1 == NULL) SWIG_fail;
11187 temp1 = true;
11188 }
11189 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11190 if (!SWIG_IsOK(res2)) {
11191 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11192 }
11193 if (!argp2) {
11194 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11195 }
11196 arg2 = reinterpret_cast< wxImage * >(argp2);
11197 ecode3 = SWIG_AsVal_long(obj2, &val3);
11198 if (!SWIG_IsOK(ecode3)) {
11199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11200 }
11201 arg3 = static_cast< long >(val3);
11202 {
11203 PyThreadState* __tstate = wxPyBeginAllowThreads();
11204 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11205 wxPyEndAllowThreads(__tstate);
11206 if (PyErr_Occurred()) SWIG_fail;
11207 }
11208 resultobj = SWIG_Py_Void();
11209 {
11210 if (temp1)
11211 delete arg1;
11212 }
11213 return resultobj;
11214 fail:
11215 {
11216 if (temp1)
11217 delete arg1;
11218 }
11219 return NULL;
11220 }
11221
11222
11223 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11224 PyObject *resultobj = 0;
11225 wxString *arg1 = 0 ;
11226 wxBitmap *arg2 = 0 ;
11227 long arg3 ;
11228 bool temp1 = false ;
11229 void *argp2 = 0 ;
11230 int res2 = 0 ;
11231 long val3 ;
11232 int ecode3 = 0 ;
11233 PyObject * obj0 = 0 ;
11234 PyObject * obj1 = 0 ;
11235 PyObject * obj2 = 0 ;
11236 char * kwnames[] = {
11237 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11238 };
11239
11240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11241 {
11242 arg1 = wxString_in_helper(obj0);
11243 if (arg1 == NULL) SWIG_fail;
11244 temp1 = true;
11245 }
11246 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11247 if (!SWIG_IsOK(res2)) {
11248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11249 }
11250 if (!argp2) {
11251 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11252 }
11253 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11254 ecode3 = SWIG_AsVal_long(obj2, &val3);
11255 if (!SWIG_IsOK(ecode3)) {
11256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11257 }
11258 arg3 = static_cast< long >(val3);
11259 {
11260 PyThreadState* __tstate = wxPyBeginAllowThreads();
11261 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11262 wxPyEndAllowThreads(__tstate);
11263 if (PyErr_Occurred()) SWIG_fail;
11264 }
11265 resultobj = SWIG_Py_Void();
11266 {
11267 if (temp1)
11268 delete arg1;
11269 }
11270 return resultobj;
11271 fail:
11272 {
11273 if (temp1)
11274 delete arg1;
11275 }
11276 return NULL;
11277 }
11278
11279
11280 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11281 PyObject *resultobj = 0;
11282 wxString *arg1 = 0 ;
11283 PyObject *arg2 = (PyObject *) 0 ;
11284 bool temp1 = false ;
11285 PyObject * obj0 = 0 ;
11286 PyObject * obj1 = 0 ;
11287 char * kwnames[] = {
11288 (char *) "filename",(char *) "data", NULL
11289 };
11290
11291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11292 {
11293 arg1 = wxString_in_helper(obj0);
11294 if (arg1 == NULL) SWIG_fail;
11295 temp1 = true;
11296 }
11297 arg2 = obj1;
11298 {
11299 PyThreadState* __tstate = wxPyBeginAllowThreads();
11300 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11301 wxPyEndAllowThreads(__tstate);
11302 if (PyErr_Occurred()) SWIG_fail;
11303 }
11304 resultobj = SWIG_Py_Void();
11305 {
11306 if (temp1)
11307 delete arg1;
11308 }
11309 return resultobj;
11310 fail:
11311 {
11312 if (temp1)
11313 delete arg1;
11314 }
11315 return NULL;
11316 }
11317
11318
11319 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11320 PyObject *resultobj = 0;
11321 wxMemoryFSHandler *result = 0 ;
11322
11323 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11324 {
11325 PyThreadState* __tstate = wxPyBeginAllowThreads();
11326 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11327 wxPyEndAllowThreads(__tstate);
11328 if (PyErr_Occurred()) SWIG_fail;
11329 }
11330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11331 return resultobj;
11332 fail:
11333 return NULL;
11334 }
11335
11336
11337 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11338 PyObject *resultobj = 0;
11339 wxString *arg1 = 0 ;
11340 bool temp1 = false ;
11341 PyObject * obj0 = 0 ;
11342 char * kwnames[] = {
11343 (char *) "filename", NULL
11344 };
11345
11346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11347 {
11348 arg1 = wxString_in_helper(obj0);
11349 if (arg1 == NULL) SWIG_fail;
11350 temp1 = true;
11351 }
11352 {
11353 PyThreadState* __tstate = wxPyBeginAllowThreads();
11354 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11355 wxPyEndAllowThreads(__tstate);
11356 if (PyErr_Occurred()) SWIG_fail;
11357 }
11358 resultobj = SWIG_Py_Void();
11359 {
11360 if (temp1)
11361 delete arg1;
11362 }
11363 return resultobj;
11364 fail:
11365 {
11366 if (temp1)
11367 delete arg1;
11368 }
11369 return NULL;
11370 }
11371
11372
11373 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11374 PyObject *resultobj = 0;
11375 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11376 wxString *arg2 = 0 ;
11377 bool result;
11378 void *argp1 = 0 ;
11379 int res1 = 0 ;
11380 bool temp2 = false ;
11381 PyObject * obj0 = 0 ;
11382 PyObject * obj1 = 0 ;
11383 char * kwnames[] = {
11384 (char *) "self",(char *) "location", NULL
11385 };
11386
11387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11389 if (!SWIG_IsOK(res1)) {
11390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11391 }
11392 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11393 {
11394 arg2 = wxString_in_helper(obj1);
11395 if (arg2 == NULL) SWIG_fail;
11396 temp2 = true;
11397 }
11398 {
11399 PyThreadState* __tstate = wxPyBeginAllowThreads();
11400 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11401 wxPyEndAllowThreads(__tstate);
11402 if (PyErr_Occurred()) SWIG_fail;
11403 }
11404 {
11405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11406 }
11407 {
11408 if (temp2)
11409 delete arg2;
11410 }
11411 return resultobj;
11412 fail:
11413 {
11414 if (temp2)
11415 delete arg2;
11416 }
11417 return NULL;
11418 }
11419
11420
11421 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11422 PyObject *resultobj = 0;
11423 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11424 wxFileSystem *arg2 = 0 ;
11425 wxString *arg3 = 0 ;
11426 wxFSFile *result = 0 ;
11427 void *argp1 = 0 ;
11428 int res1 = 0 ;
11429 void *argp2 = 0 ;
11430 int res2 = 0 ;
11431 bool temp3 = false ;
11432 PyObject * obj0 = 0 ;
11433 PyObject * obj1 = 0 ;
11434 PyObject * obj2 = 0 ;
11435 char * kwnames[] = {
11436 (char *) "self",(char *) "fs",(char *) "location", NULL
11437 };
11438
11439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11441 if (!SWIG_IsOK(res1)) {
11442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11443 }
11444 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11445 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11446 if (!SWIG_IsOK(res2)) {
11447 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11448 }
11449 if (!argp2) {
11450 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11451 }
11452 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11453 {
11454 arg3 = wxString_in_helper(obj2);
11455 if (arg3 == NULL) SWIG_fail;
11456 temp3 = true;
11457 }
11458 {
11459 PyThreadState* __tstate = wxPyBeginAllowThreads();
11460 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11461 wxPyEndAllowThreads(__tstate);
11462 if (PyErr_Occurred()) SWIG_fail;
11463 }
11464 {
11465 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11466 }
11467 {
11468 if (temp3)
11469 delete arg3;
11470 }
11471 return resultobj;
11472 fail:
11473 {
11474 if (temp3)
11475 delete arg3;
11476 }
11477 return NULL;
11478 }
11479
11480
11481 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11482 PyObject *resultobj = 0;
11483 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11484 wxString *arg2 = 0 ;
11485 int arg3 = (int) 0 ;
11486 wxString result;
11487 void *argp1 = 0 ;
11488 int res1 = 0 ;
11489 bool temp2 = false ;
11490 int val3 ;
11491 int ecode3 = 0 ;
11492 PyObject * obj0 = 0 ;
11493 PyObject * obj1 = 0 ;
11494 PyObject * obj2 = 0 ;
11495 char * kwnames[] = {
11496 (char *) "self",(char *) "spec",(char *) "flags", NULL
11497 };
11498
11499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11501 if (!SWIG_IsOK(res1)) {
11502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11503 }
11504 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11505 {
11506 arg2 = wxString_in_helper(obj1);
11507 if (arg2 == NULL) SWIG_fail;
11508 temp2 = true;
11509 }
11510 if (obj2) {
11511 ecode3 = SWIG_AsVal_int(obj2, &val3);
11512 if (!SWIG_IsOK(ecode3)) {
11513 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11514 }
11515 arg3 = static_cast< int >(val3);
11516 }
11517 {
11518 PyThreadState* __tstate = wxPyBeginAllowThreads();
11519 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11520 wxPyEndAllowThreads(__tstate);
11521 if (PyErr_Occurred()) SWIG_fail;
11522 }
11523 {
11524 #if wxUSE_UNICODE
11525 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11526 #else
11527 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11528 #endif
11529 }
11530 {
11531 if (temp2)
11532 delete arg2;
11533 }
11534 return resultobj;
11535 fail:
11536 {
11537 if (temp2)
11538 delete arg2;
11539 }
11540 return NULL;
11541 }
11542
11543
11544 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11545 PyObject *resultobj = 0;
11546 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11547 wxString result;
11548 void *argp1 = 0 ;
11549 int res1 = 0 ;
11550 PyObject *swig_obj[1] ;
11551
11552 if (!args) SWIG_fail;
11553 swig_obj[0] = args;
11554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11555 if (!SWIG_IsOK(res1)) {
11556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11557 }
11558 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11559 {
11560 PyThreadState* __tstate = wxPyBeginAllowThreads();
11561 result = (arg1)->FindNext();
11562 wxPyEndAllowThreads(__tstate);
11563 if (PyErr_Occurred()) SWIG_fail;
11564 }
11565 {
11566 #if wxUSE_UNICODE
11567 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11568 #else
11569 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11570 #endif
11571 }
11572 return resultobj;
11573 fail:
11574 return NULL;
11575 }
11576
11577
11578 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11579 PyObject *obj;
11580 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11581 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11582 return SWIG_Py_Void();
11583 }
11584
11585 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11586 return SWIG_Python_InitShadowInstance(args);
11587 }
11588
11589 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11590 PyObject *resultobj = 0;
11591 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11592 wxString result;
11593 void *argp1 = 0 ;
11594 int res1 = 0 ;
11595 PyObject *swig_obj[1] ;
11596
11597 if (!args) SWIG_fail;
11598 swig_obj[0] = args;
11599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11600 if (!SWIG_IsOK(res1)) {
11601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11602 }
11603 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11604 {
11605 PyThreadState* __tstate = wxPyBeginAllowThreads();
11606 result = (arg1)->GetName();
11607 wxPyEndAllowThreads(__tstate);
11608 if (PyErr_Occurred()) SWIG_fail;
11609 }
11610 {
11611 #if wxUSE_UNICODE
11612 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11613 #else
11614 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11615 #endif
11616 }
11617 return resultobj;
11618 fail:
11619 return NULL;
11620 }
11621
11622
11623 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11624 PyObject *resultobj = 0;
11625 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11626 wxString result;
11627 void *argp1 = 0 ;
11628 int res1 = 0 ;
11629 PyObject *swig_obj[1] ;
11630
11631 if (!args) SWIG_fail;
11632 swig_obj[0] = args;
11633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11634 if (!SWIG_IsOK(res1)) {
11635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11636 }
11637 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11638 {
11639 PyThreadState* __tstate = wxPyBeginAllowThreads();
11640 result = (arg1)->GetExtension();
11641 wxPyEndAllowThreads(__tstate);
11642 if (PyErr_Occurred()) SWIG_fail;
11643 }
11644 {
11645 #if wxUSE_UNICODE
11646 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11647 #else
11648 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11649 #endif
11650 }
11651 return resultobj;
11652 fail:
11653 return NULL;
11654 }
11655
11656
11657 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11658 PyObject *resultobj = 0;
11659 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11660 long result;
11661 void *argp1 = 0 ;
11662 int res1 = 0 ;
11663 PyObject *swig_obj[1] ;
11664
11665 if (!args) SWIG_fail;
11666 swig_obj[0] = args;
11667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11668 if (!SWIG_IsOK(res1)) {
11669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11670 }
11671 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11672 {
11673 PyThreadState* __tstate = wxPyBeginAllowThreads();
11674 result = (long)(arg1)->GetType();
11675 wxPyEndAllowThreads(__tstate);
11676 if (PyErr_Occurred()) SWIG_fail;
11677 }
11678 resultobj = SWIG_From_long(static_cast< long >(result));
11679 return resultobj;
11680 fail:
11681 return NULL;
11682 }
11683
11684
11685 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11686 PyObject *resultobj = 0;
11687 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11688 wxString result;
11689 void *argp1 = 0 ;
11690 int res1 = 0 ;
11691 PyObject *swig_obj[1] ;
11692
11693 if (!args) SWIG_fail;
11694 swig_obj[0] = args;
11695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11696 if (!SWIG_IsOK(res1)) {
11697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11698 }
11699 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11700 {
11701 PyThreadState* __tstate = wxPyBeginAllowThreads();
11702 result = (arg1)->GetMimeType();
11703 wxPyEndAllowThreads(__tstate);
11704 if (PyErr_Occurred()) SWIG_fail;
11705 }
11706 {
11707 #if wxUSE_UNICODE
11708 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11709 #else
11710 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11711 #endif
11712 }
11713 return resultobj;
11714 fail:
11715 return NULL;
11716 }
11717
11718
11719 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11720 PyObject *resultobj = 0;
11721 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11722 wxString *arg2 = 0 ;
11723 bool result;
11724 void *argp1 = 0 ;
11725 int res1 = 0 ;
11726 bool temp2 = false ;
11727 PyObject * obj0 = 0 ;
11728 PyObject * obj1 = 0 ;
11729 char * kwnames[] = {
11730 (char *) "self",(char *) "name", NULL
11731 };
11732
11733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11735 if (!SWIG_IsOK(res1)) {
11736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11737 }
11738 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11739 {
11740 arg2 = wxString_in_helper(obj1);
11741 if (arg2 == NULL) SWIG_fail;
11742 temp2 = true;
11743 }
11744 {
11745 PyThreadState* __tstate = wxPyBeginAllowThreads();
11746 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11747 wxPyEndAllowThreads(__tstate);
11748 if (PyErr_Occurred()) SWIG_fail;
11749 }
11750 {
11751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11752 }
11753 {
11754 if (temp2)
11755 delete arg2;
11756 }
11757 return resultobj;
11758 fail:
11759 {
11760 if (temp2)
11761 delete arg2;
11762 }
11763 return NULL;
11764 }
11765
11766
11767 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11768 PyObject *resultobj = 0;
11769 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11770 wxString *arg2 = 0 ;
11771 void *argp1 = 0 ;
11772 int res1 = 0 ;
11773 bool temp2 = false ;
11774 PyObject * obj0 = 0 ;
11775 PyObject * obj1 = 0 ;
11776 char * kwnames[] = {
11777 (char *) "self",(char *) "name", NULL
11778 };
11779
11780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11782 if (!SWIG_IsOK(res1)) {
11783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11784 }
11785 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11786 {
11787 arg2 = wxString_in_helper(obj1);
11788 if (arg2 == NULL) SWIG_fail;
11789 temp2 = true;
11790 }
11791 {
11792 PyThreadState* __tstate = wxPyBeginAllowThreads();
11793 (arg1)->SetName((wxString const &)*arg2);
11794 wxPyEndAllowThreads(__tstate);
11795 if (PyErr_Occurred()) SWIG_fail;
11796 }
11797 resultobj = SWIG_Py_Void();
11798 {
11799 if (temp2)
11800 delete arg2;
11801 }
11802 return resultobj;
11803 fail:
11804 {
11805 if (temp2)
11806 delete arg2;
11807 }
11808 return NULL;
11809 }
11810
11811
11812 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11813 PyObject *resultobj = 0;
11814 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11815 wxString *arg2 = 0 ;
11816 void *argp1 = 0 ;
11817 int res1 = 0 ;
11818 bool temp2 = false ;
11819 PyObject * obj0 = 0 ;
11820 PyObject * obj1 = 0 ;
11821 char * kwnames[] = {
11822 (char *) "self",(char *) "extension", NULL
11823 };
11824
11825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11827 if (!SWIG_IsOK(res1)) {
11828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11829 }
11830 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11831 {
11832 arg2 = wxString_in_helper(obj1);
11833 if (arg2 == NULL) SWIG_fail;
11834 temp2 = true;
11835 }
11836 {
11837 PyThreadState* __tstate = wxPyBeginAllowThreads();
11838 (arg1)->SetExtension((wxString const &)*arg2);
11839 wxPyEndAllowThreads(__tstate);
11840 if (PyErr_Occurred()) SWIG_fail;
11841 }
11842 resultobj = SWIG_Py_Void();
11843 {
11844 if (temp2)
11845 delete arg2;
11846 }
11847 return resultobj;
11848 fail:
11849 {
11850 if (temp2)
11851 delete arg2;
11852 }
11853 return NULL;
11854 }
11855
11856
11857 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11858 PyObject *resultobj = 0;
11859 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11860 long arg2 ;
11861 void *argp1 = 0 ;
11862 int res1 = 0 ;
11863 long val2 ;
11864 int ecode2 = 0 ;
11865 PyObject * obj0 = 0 ;
11866 PyObject * obj1 = 0 ;
11867 char * kwnames[] = {
11868 (char *) "self",(char *) "type", NULL
11869 };
11870
11871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11873 if (!SWIG_IsOK(res1)) {
11874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11875 }
11876 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11877 ecode2 = SWIG_AsVal_long(obj1, &val2);
11878 if (!SWIG_IsOK(ecode2)) {
11879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11880 }
11881 arg2 = static_cast< long >(val2);
11882 {
11883 PyThreadState* __tstate = wxPyBeginAllowThreads();
11884 (arg1)->SetType(arg2);
11885 wxPyEndAllowThreads(__tstate);
11886 if (PyErr_Occurred()) SWIG_fail;
11887 }
11888 resultobj = SWIG_Py_Void();
11889 return resultobj;
11890 fail:
11891 return NULL;
11892 }
11893
11894
11895 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11896 PyObject *resultobj = 0;
11897 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11898 wxString *arg2 = 0 ;
11899 void *argp1 = 0 ;
11900 int res1 = 0 ;
11901 bool temp2 = false ;
11902 PyObject * obj0 = 0 ;
11903 PyObject * obj1 = 0 ;
11904 char * kwnames[] = {
11905 (char *) "self",(char *) "mimetype", NULL
11906 };
11907
11908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
11909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11910 if (!SWIG_IsOK(res1)) {
11911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11912 }
11913 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11914 {
11915 arg2 = wxString_in_helper(obj1);
11916 if (arg2 == NULL) SWIG_fail;
11917 temp2 = true;
11918 }
11919 {
11920 PyThreadState* __tstate = wxPyBeginAllowThreads();
11921 (arg1)->SetMimeType((wxString const &)*arg2);
11922 wxPyEndAllowThreads(__tstate);
11923 if (PyErr_Occurred()) SWIG_fail;
11924 }
11925 resultobj = SWIG_Py_Void();
11926 {
11927 if (temp2)
11928 delete arg2;
11929 }
11930 return resultobj;
11931 fail:
11932 {
11933 if (temp2)
11934 delete arg2;
11935 }
11936 return NULL;
11937 }
11938
11939
11940 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11941 PyObject *obj;
11942 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11943 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
11944 return SWIG_Py_Void();
11945 }
11946
11947 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11948 PyObject *resultobj = 0;
11949 wxPyImageHandler *result = 0 ;
11950
11951 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
11952 {
11953 PyThreadState* __tstate = wxPyBeginAllowThreads();
11954 result = (wxPyImageHandler *)new wxPyImageHandler();
11955 wxPyEndAllowThreads(__tstate);
11956 if (PyErr_Occurred()) SWIG_fail;
11957 }
11958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
11959 return resultobj;
11960 fail:
11961 return NULL;
11962 }
11963
11964
11965 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11966 PyObject *resultobj = 0;
11967 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
11968 PyObject *arg2 = (PyObject *) 0 ;
11969 void *argp1 = 0 ;
11970 int res1 = 0 ;
11971 PyObject * obj0 = 0 ;
11972 PyObject * obj1 = 0 ;
11973 char * kwnames[] = {
11974 (char *) "self",(char *) "self", NULL
11975 };
11976
11977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
11978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
11979 if (!SWIG_IsOK(res1)) {
11980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
11981 }
11982 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
11983 arg2 = obj1;
11984 {
11985 PyThreadState* __tstate = wxPyBeginAllowThreads();
11986 (arg1)->_SetSelf(arg2);
11987 wxPyEndAllowThreads(__tstate);
11988 if (PyErr_Occurred()) SWIG_fail;
11989 }
11990 resultobj = SWIG_Py_Void();
11991 return resultobj;
11992 fail:
11993 return NULL;
11994 }
11995
11996
11997 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11998 PyObject *obj;
11999 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12000 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12001 return SWIG_Py_Void();
12002 }
12003
12004 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12005 return SWIG_Python_InitShadowInstance(args);
12006 }
12007
12008 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12009 PyObject *resultobj = 0;
12010 wxImageHistogram *result = 0 ;
12011
12012 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12013 {
12014 PyThreadState* __tstate = wxPyBeginAllowThreads();
12015 result = (wxImageHistogram *)new wxImageHistogram();
12016 wxPyEndAllowThreads(__tstate);
12017 if (PyErr_Occurred()) SWIG_fail;
12018 }
12019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12020 return resultobj;
12021 fail:
12022 return NULL;
12023 }
12024
12025
12026 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12027 PyObject *resultobj = 0;
12028 byte arg1 ;
12029 byte arg2 ;
12030 byte arg3 ;
12031 unsigned long result;
12032 unsigned char val1 ;
12033 int ecode1 = 0 ;
12034 unsigned char val2 ;
12035 int ecode2 = 0 ;
12036 unsigned char val3 ;
12037 int ecode3 = 0 ;
12038 PyObject * obj0 = 0 ;
12039 PyObject * obj1 = 0 ;
12040 PyObject * obj2 = 0 ;
12041 char * kwnames[] = {
12042 (char *) "r",(char *) "g",(char *) "b", NULL
12043 };
12044
12045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12046 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12047 if (!SWIG_IsOK(ecode1)) {
12048 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12049 }
12050 arg1 = static_cast< byte >(val1);
12051 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12052 if (!SWIG_IsOK(ecode2)) {
12053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12054 }
12055 arg2 = static_cast< byte >(val2);
12056 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12057 if (!SWIG_IsOK(ecode3)) {
12058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12059 }
12060 arg3 = static_cast< byte >(val3);
12061 {
12062 PyThreadState* __tstate = wxPyBeginAllowThreads();
12063 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12064 wxPyEndAllowThreads(__tstate);
12065 if (PyErr_Occurred()) SWIG_fail;
12066 }
12067 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12068 return resultobj;
12069 fail:
12070 return NULL;
12071 }
12072
12073
12074 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12075 PyObject *resultobj = 0;
12076 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12077 byte *arg2 = (byte *) 0 ;
12078 byte *arg3 = (byte *) 0 ;
12079 byte *arg4 = (byte *) 0 ;
12080 byte arg5 = (byte) 1 ;
12081 byte arg6 = (byte) 0 ;
12082 byte arg7 = (byte) 0 ;
12083 bool result;
12084 void *argp1 = 0 ;
12085 int res1 = 0 ;
12086 byte temp2 ;
12087 int res2 = SWIG_TMPOBJ ;
12088 byte temp3 ;
12089 int res3 = SWIG_TMPOBJ ;
12090 byte temp4 ;
12091 int res4 = SWIG_TMPOBJ ;
12092 unsigned char val5 ;
12093 int ecode5 = 0 ;
12094 unsigned char val6 ;
12095 int ecode6 = 0 ;
12096 unsigned char val7 ;
12097 int ecode7 = 0 ;
12098 PyObject * obj0 = 0 ;
12099 PyObject * obj1 = 0 ;
12100 PyObject * obj2 = 0 ;
12101 PyObject * obj3 = 0 ;
12102 char * kwnames[] = {
12103 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12104 };
12105
12106 arg2 = &temp2;
12107 arg3 = &temp3;
12108 arg4 = &temp4;
12109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12111 if (!SWIG_IsOK(res1)) {
12112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12113 }
12114 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12115 if (obj1) {
12116 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12117 if (!SWIG_IsOK(ecode5)) {
12118 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12119 }
12120 arg5 = static_cast< byte >(val5);
12121 }
12122 if (obj2) {
12123 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12124 if (!SWIG_IsOK(ecode6)) {
12125 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12126 }
12127 arg6 = static_cast< byte >(val6);
12128 }
12129 if (obj3) {
12130 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12131 if (!SWIG_IsOK(ecode7)) {
12132 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12133 }
12134 arg7 = static_cast< byte >(val7);
12135 }
12136 {
12137 PyThreadState* __tstate = wxPyBeginAllowThreads();
12138 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12139 wxPyEndAllowThreads(__tstate);
12140 if (PyErr_Occurred()) SWIG_fail;
12141 }
12142 {
12143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12144 }
12145 if (SWIG_IsTmpObj(res2)) {
12146 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12147 } else {
12148 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12149 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12150 }
12151 if (SWIG_IsTmpObj(res3)) {
12152 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12153 } else {
12154 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12155 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12156 }
12157 if (SWIG_IsTmpObj(res4)) {
12158 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12159 } else {
12160 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12161 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12162 }
12163 return resultobj;
12164 fail:
12165 return NULL;
12166 }
12167
12168
12169 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12170 PyObject *resultobj = 0;
12171 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12172 unsigned long arg2 ;
12173 unsigned long result;
12174 void *argp1 = 0 ;
12175 int res1 = 0 ;
12176 unsigned long val2 ;
12177 int ecode2 = 0 ;
12178 PyObject * obj0 = 0 ;
12179 PyObject * obj1 = 0 ;
12180 char * kwnames[] = {
12181 (char *) "self",(char *) "key", NULL
12182 };
12183
12184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12186 if (!SWIG_IsOK(res1)) {
12187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12188 }
12189 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12190 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12191 if (!SWIG_IsOK(ecode2)) {
12192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12193 }
12194 arg2 = static_cast< unsigned long >(val2);
12195 {
12196 PyThreadState* __tstate = wxPyBeginAllowThreads();
12197 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12198 wxPyEndAllowThreads(__tstate);
12199 if (PyErr_Occurred()) SWIG_fail;
12200 }
12201 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12202 return resultobj;
12203 fail:
12204 return NULL;
12205 }
12206
12207
12208 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12209 PyObject *resultobj = 0;
12210 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12211 byte arg2 ;
12212 byte arg3 ;
12213 byte arg4 ;
12214 unsigned long result;
12215 void *argp1 = 0 ;
12216 int res1 = 0 ;
12217 unsigned char val2 ;
12218 int ecode2 = 0 ;
12219 unsigned char val3 ;
12220 int ecode3 = 0 ;
12221 unsigned char val4 ;
12222 int ecode4 = 0 ;
12223 PyObject * obj0 = 0 ;
12224 PyObject * obj1 = 0 ;
12225 PyObject * obj2 = 0 ;
12226 PyObject * obj3 = 0 ;
12227 char * kwnames[] = {
12228 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12229 };
12230
12231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12233 if (!SWIG_IsOK(res1)) {
12234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12235 }
12236 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12237 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12238 if (!SWIG_IsOK(ecode2)) {
12239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12240 }
12241 arg2 = static_cast< byte >(val2);
12242 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12243 if (!SWIG_IsOK(ecode3)) {
12244 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12245 }
12246 arg3 = static_cast< byte >(val3);
12247 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12248 if (!SWIG_IsOK(ecode4)) {
12249 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12250 }
12251 arg4 = static_cast< byte >(val4);
12252 {
12253 PyThreadState* __tstate = wxPyBeginAllowThreads();
12254 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12255 wxPyEndAllowThreads(__tstate);
12256 if (PyErr_Occurred()) SWIG_fail;
12257 }
12258 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12259 return resultobj;
12260 fail:
12261 return NULL;
12262 }
12263
12264
12265 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12266 PyObject *resultobj = 0;
12267 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12268 wxColour *arg2 = 0 ;
12269 unsigned long result;
12270 void *argp1 = 0 ;
12271 int res1 = 0 ;
12272 wxColour temp2 ;
12273 PyObject * obj0 = 0 ;
12274 PyObject * obj1 = 0 ;
12275 char * kwnames[] = {
12276 (char *) "self",(char *) "colour", NULL
12277 };
12278
12279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12281 if (!SWIG_IsOK(res1)) {
12282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12283 }
12284 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12285 {
12286 arg2 = &temp2;
12287 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12288 }
12289 {
12290 PyThreadState* __tstate = wxPyBeginAllowThreads();
12291 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12292 wxPyEndAllowThreads(__tstate);
12293 if (PyErr_Occurred()) SWIG_fail;
12294 }
12295 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12296 return resultobj;
12297 fail:
12298 return NULL;
12299 }
12300
12301
12302 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12303 PyObject *obj;
12304 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12305 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12306 return SWIG_Py_Void();
12307 }
12308
12309 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12310 return SWIG_Python_InitShadowInstance(args);
12311 }
12312
12313 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12314 PyObject *resultobj = 0;
12315 byte arg1 = (byte) 0 ;
12316 byte arg2 = (byte) 0 ;
12317 byte arg3 = (byte) 0 ;
12318 wxImage_RGBValue *result = 0 ;
12319 unsigned char val1 ;
12320 int ecode1 = 0 ;
12321 unsigned char val2 ;
12322 int ecode2 = 0 ;
12323 unsigned char val3 ;
12324 int ecode3 = 0 ;
12325 PyObject * obj0 = 0 ;
12326 PyObject * obj1 = 0 ;
12327 PyObject * obj2 = 0 ;
12328 char * kwnames[] = {
12329 (char *) "r",(char *) "g",(char *) "b", NULL
12330 };
12331
12332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12333 if (obj0) {
12334 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12335 if (!SWIG_IsOK(ecode1)) {
12336 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12337 }
12338 arg1 = static_cast< byte >(val1);
12339 }
12340 if (obj1) {
12341 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12342 if (!SWIG_IsOK(ecode2)) {
12343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12344 }
12345 arg2 = static_cast< byte >(val2);
12346 }
12347 if (obj2) {
12348 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12349 if (!SWIG_IsOK(ecode3)) {
12350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12351 }
12352 arg3 = static_cast< byte >(val3);
12353 }
12354 {
12355 PyThreadState* __tstate = wxPyBeginAllowThreads();
12356 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12357 wxPyEndAllowThreads(__tstate);
12358 if (PyErr_Occurred()) SWIG_fail;
12359 }
12360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12361 return resultobj;
12362 fail:
12363 return NULL;
12364 }
12365
12366
12367 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12368 PyObject *resultobj = 0;
12369 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12370 byte arg2 ;
12371 void *argp1 = 0 ;
12372 int res1 = 0 ;
12373 unsigned char val2 ;
12374 int ecode2 = 0 ;
12375 PyObject *swig_obj[2] ;
12376
12377 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12379 if (!SWIG_IsOK(res1)) {
12380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12381 }
12382 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12383 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12384 if (!SWIG_IsOK(ecode2)) {
12385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12386 }
12387 arg2 = static_cast< byte >(val2);
12388 if (arg1) (arg1)->red = arg2;
12389
12390 resultobj = SWIG_Py_Void();
12391 return resultobj;
12392 fail:
12393 return NULL;
12394 }
12395
12396
12397 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12398 PyObject *resultobj = 0;
12399 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12400 byte result;
12401 void *argp1 = 0 ;
12402 int res1 = 0 ;
12403 PyObject *swig_obj[1] ;
12404
12405 if (!args) SWIG_fail;
12406 swig_obj[0] = args;
12407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12408 if (!SWIG_IsOK(res1)) {
12409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12410 }
12411 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12412 result = (byte) ((arg1)->red);
12413 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12414 return resultobj;
12415 fail:
12416 return NULL;
12417 }
12418
12419
12420 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12421 PyObject *resultobj = 0;
12422 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12423 byte arg2 ;
12424 void *argp1 = 0 ;
12425 int res1 = 0 ;
12426 unsigned char val2 ;
12427 int ecode2 = 0 ;
12428 PyObject *swig_obj[2] ;
12429
12430 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12432 if (!SWIG_IsOK(res1)) {
12433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12434 }
12435 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12436 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12437 if (!SWIG_IsOK(ecode2)) {
12438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12439 }
12440 arg2 = static_cast< byte >(val2);
12441 if (arg1) (arg1)->green = arg2;
12442
12443 resultobj = SWIG_Py_Void();
12444 return resultobj;
12445 fail:
12446 return NULL;
12447 }
12448
12449
12450 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12451 PyObject *resultobj = 0;
12452 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12453 byte result;
12454 void *argp1 = 0 ;
12455 int res1 = 0 ;
12456 PyObject *swig_obj[1] ;
12457
12458 if (!args) SWIG_fail;
12459 swig_obj[0] = args;
12460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12461 if (!SWIG_IsOK(res1)) {
12462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12463 }
12464 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12465 result = (byte) ((arg1)->green);
12466 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12467 return resultobj;
12468 fail:
12469 return NULL;
12470 }
12471
12472
12473 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12474 PyObject *resultobj = 0;
12475 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12476 byte arg2 ;
12477 void *argp1 = 0 ;
12478 int res1 = 0 ;
12479 unsigned char val2 ;
12480 int ecode2 = 0 ;
12481 PyObject *swig_obj[2] ;
12482
12483 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12485 if (!SWIG_IsOK(res1)) {
12486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12487 }
12488 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12489 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12490 if (!SWIG_IsOK(ecode2)) {
12491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12492 }
12493 arg2 = static_cast< byte >(val2);
12494 if (arg1) (arg1)->blue = arg2;
12495
12496 resultobj = SWIG_Py_Void();
12497 return resultobj;
12498 fail:
12499 return NULL;
12500 }
12501
12502
12503 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12504 PyObject *resultobj = 0;
12505 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12506 byte result;
12507 void *argp1 = 0 ;
12508 int res1 = 0 ;
12509 PyObject *swig_obj[1] ;
12510
12511 if (!args) SWIG_fail;
12512 swig_obj[0] = args;
12513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12514 if (!SWIG_IsOK(res1)) {
12515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12516 }
12517 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12518 result = (byte) ((arg1)->blue);
12519 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12520 return resultobj;
12521 fail:
12522 return NULL;
12523 }
12524
12525
12526 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12527 PyObject *obj;
12528 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12529 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12530 return SWIG_Py_Void();
12531 }
12532
12533 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12534 return SWIG_Python_InitShadowInstance(args);
12535 }
12536
12537 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12538 PyObject *resultobj = 0;
12539 double arg1 = (double) 0.0 ;
12540 double arg2 = (double) 0.0 ;
12541 double arg3 = (double) 0.0 ;
12542 wxImage_HSVValue *result = 0 ;
12543 double val1 ;
12544 int ecode1 = 0 ;
12545 double val2 ;
12546 int ecode2 = 0 ;
12547 double val3 ;
12548 int ecode3 = 0 ;
12549 PyObject * obj0 = 0 ;
12550 PyObject * obj1 = 0 ;
12551 PyObject * obj2 = 0 ;
12552 char * kwnames[] = {
12553 (char *) "h",(char *) "s",(char *) "v", NULL
12554 };
12555
12556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12557 if (obj0) {
12558 ecode1 = SWIG_AsVal_double(obj0, &val1);
12559 if (!SWIG_IsOK(ecode1)) {
12560 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12561 }
12562 arg1 = static_cast< double >(val1);
12563 }
12564 if (obj1) {
12565 ecode2 = SWIG_AsVal_double(obj1, &val2);
12566 if (!SWIG_IsOK(ecode2)) {
12567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12568 }
12569 arg2 = static_cast< double >(val2);
12570 }
12571 if (obj2) {
12572 ecode3 = SWIG_AsVal_double(obj2, &val3);
12573 if (!SWIG_IsOK(ecode3)) {
12574 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12575 }
12576 arg3 = static_cast< double >(val3);
12577 }
12578 {
12579 PyThreadState* __tstate = wxPyBeginAllowThreads();
12580 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12581 wxPyEndAllowThreads(__tstate);
12582 if (PyErr_Occurred()) SWIG_fail;
12583 }
12584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12585 return resultobj;
12586 fail:
12587 return NULL;
12588 }
12589
12590
12591 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12592 PyObject *resultobj = 0;
12593 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12594 double arg2 ;
12595 void *argp1 = 0 ;
12596 int res1 = 0 ;
12597 double val2 ;
12598 int ecode2 = 0 ;
12599 PyObject *swig_obj[2] ;
12600
12601 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12603 if (!SWIG_IsOK(res1)) {
12604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12605 }
12606 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12607 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12608 if (!SWIG_IsOK(ecode2)) {
12609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12610 }
12611 arg2 = static_cast< double >(val2);
12612 if (arg1) (arg1)->hue = arg2;
12613
12614 resultobj = SWIG_Py_Void();
12615 return resultobj;
12616 fail:
12617 return NULL;
12618 }
12619
12620
12621 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12622 PyObject *resultobj = 0;
12623 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12624 double result;
12625 void *argp1 = 0 ;
12626 int res1 = 0 ;
12627 PyObject *swig_obj[1] ;
12628
12629 if (!args) SWIG_fail;
12630 swig_obj[0] = args;
12631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12632 if (!SWIG_IsOK(res1)) {
12633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12634 }
12635 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12636 result = (double) ((arg1)->hue);
12637 resultobj = SWIG_From_double(static_cast< double >(result));
12638 return resultobj;
12639 fail:
12640 return NULL;
12641 }
12642
12643
12644 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12645 PyObject *resultobj = 0;
12646 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12647 double arg2 ;
12648 void *argp1 = 0 ;
12649 int res1 = 0 ;
12650 double val2 ;
12651 int ecode2 = 0 ;
12652 PyObject *swig_obj[2] ;
12653
12654 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12656 if (!SWIG_IsOK(res1)) {
12657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12658 }
12659 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12660 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12661 if (!SWIG_IsOK(ecode2)) {
12662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12663 }
12664 arg2 = static_cast< double >(val2);
12665 if (arg1) (arg1)->saturation = arg2;
12666
12667 resultobj = SWIG_Py_Void();
12668 return resultobj;
12669 fail:
12670 return NULL;
12671 }
12672
12673
12674 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12675 PyObject *resultobj = 0;
12676 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12677 double result;
12678 void *argp1 = 0 ;
12679 int res1 = 0 ;
12680 PyObject *swig_obj[1] ;
12681
12682 if (!args) SWIG_fail;
12683 swig_obj[0] = args;
12684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12685 if (!SWIG_IsOK(res1)) {
12686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12687 }
12688 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12689 result = (double) ((arg1)->saturation);
12690 resultobj = SWIG_From_double(static_cast< double >(result));
12691 return resultobj;
12692 fail:
12693 return NULL;
12694 }
12695
12696
12697 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12698 PyObject *resultobj = 0;
12699 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12700 double arg2 ;
12701 void *argp1 = 0 ;
12702 int res1 = 0 ;
12703 double val2 ;
12704 int ecode2 = 0 ;
12705 PyObject *swig_obj[2] ;
12706
12707 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12709 if (!SWIG_IsOK(res1)) {
12710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12711 }
12712 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12713 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12714 if (!SWIG_IsOK(ecode2)) {
12715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12716 }
12717 arg2 = static_cast< double >(val2);
12718 if (arg1) (arg1)->value = arg2;
12719
12720 resultobj = SWIG_Py_Void();
12721 return resultobj;
12722 fail:
12723 return NULL;
12724 }
12725
12726
12727 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12728 PyObject *resultobj = 0;
12729 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12730 double result;
12731 void *argp1 = 0 ;
12732 int res1 = 0 ;
12733 PyObject *swig_obj[1] ;
12734
12735 if (!args) SWIG_fail;
12736 swig_obj[0] = args;
12737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12738 if (!SWIG_IsOK(res1)) {
12739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12740 }
12741 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12742 result = (double) ((arg1)->value);
12743 resultobj = SWIG_From_double(static_cast< double >(result));
12744 return resultobj;
12745 fail:
12746 return NULL;
12747 }
12748
12749
12750 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12751 PyObject *obj;
12752 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12753 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12754 return SWIG_Py_Void();
12755 }
12756
12757 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12758 return SWIG_Python_InitShadowInstance(args);
12759 }
12760
12761 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12762 PyObject *resultobj = 0;
12763 wxString *arg1 = 0 ;
12764 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12765 int arg3 = (int) -1 ;
12766 wxImage *result = 0 ;
12767 bool temp1 = false ;
12768 long val2 ;
12769 int ecode2 = 0 ;
12770 int val3 ;
12771 int ecode3 = 0 ;
12772 PyObject * obj0 = 0 ;
12773 PyObject * obj1 = 0 ;
12774 PyObject * obj2 = 0 ;
12775 char * kwnames[] = {
12776 (char *) "name",(char *) "type",(char *) "index", NULL
12777 };
12778
12779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12780 {
12781 arg1 = wxString_in_helper(obj0);
12782 if (arg1 == NULL) SWIG_fail;
12783 temp1 = true;
12784 }
12785 if (obj1) {
12786 ecode2 = SWIG_AsVal_long(obj1, &val2);
12787 if (!SWIG_IsOK(ecode2)) {
12788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12789 }
12790 arg2 = static_cast< long >(val2);
12791 }
12792 if (obj2) {
12793 ecode3 = SWIG_AsVal_int(obj2, &val3);
12794 if (!SWIG_IsOK(ecode3)) {
12795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12796 }
12797 arg3 = static_cast< int >(val3);
12798 }
12799 {
12800 PyThreadState* __tstate = wxPyBeginAllowThreads();
12801 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12802 wxPyEndAllowThreads(__tstate);
12803 if (PyErr_Occurred()) SWIG_fail;
12804 }
12805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12806 {
12807 if (temp1)
12808 delete arg1;
12809 }
12810 return resultobj;
12811 fail:
12812 {
12813 if (temp1)
12814 delete arg1;
12815 }
12816 return NULL;
12817 }
12818
12819
12820 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12821 PyObject *resultobj = 0;
12822 wxImage *arg1 = (wxImage *) 0 ;
12823 void *argp1 = 0 ;
12824 int res1 = 0 ;
12825 PyObject *swig_obj[1] ;
12826
12827 if (!args) SWIG_fail;
12828 swig_obj[0] = args;
12829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12830 if (!SWIG_IsOK(res1)) {
12831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12832 }
12833 arg1 = reinterpret_cast< wxImage * >(argp1);
12834 {
12835 PyThreadState* __tstate = wxPyBeginAllowThreads();
12836 delete arg1;
12837
12838 wxPyEndAllowThreads(__tstate);
12839 if (PyErr_Occurred()) SWIG_fail;
12840 }
12841 resultobj = SWIG_Py_Void();
12842 return resultobj;
12843 fail:
12844 return NULL;
12845 }
12846
12847
12848 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12849 PyObject *resultobj = 0;
12850 wxString *arg1 = 0 ;
12851 wxString *arg2 = 0 ;
12852 int arg3 = (int) -1 ;
12853 wxImage *result = 0 ;
12854 bool temp1 = false ;
12855 bool temp2 = false ;
12856 int val3 ;
12857 int ecode3 = 0 ;
12858 PyObject * obj0 = 0 ;
12859 PyObject * obj1 = 0 ;
12860 PyObject * obj2 = 0 ;
12861 char * kwnames[] = {
12862 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12863 };
12864
12865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12866 {
12867 arg1 = wxString_in_helper(obj0);
12868 if (arg1 == NULL) SWIG_fail;
12869 temp1 = true;
12870 }
12871 {
12872 arg2 = wxString_in_helper(obj1);
12873 if (arg2 == NULL) SWIG_fail;
12874 temp2 = true;
12875 }
12876 if (obj2) {
12877 ecode3 = SWIG_AsVal_int(obj2, &val3);
12878 if (!SWIG_IsOK(ecode3)) {
12879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12880 }
12881 arg3 = static_cast< int >(val3);
12882 }
12883 {
12884 PyThreadState* __tstate = wxPyBeginAllowThreads();
12885 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12886 wxPyEndAllowThreads(__tstate);
12887 if (PyErr_Occurred()) SWIG_fail;
12888 }
12889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12890 {
12891 if (temp1)
12892 delete arg1;
12893 }
12894 {
12895 if (temp2)
12896 delete arg2;
12897 }
12898 return resultobj;
12899 fail:
12900 {
12901 if (temp1)
12902 delete arg1;
12903 }
12904 {
12905 if (temp2)
12906 delete arg2;
12907 }
12908 return NULL;
12909 }
12910
12911
12912 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12913 PyObject *resultobj = 0;
12914 wxInputStream *arg1 = 0 ;
12915 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12916 int arg3 = (int) -1 ;
12917 wxImage *result = 0 ;
12918 wxPyInputStream *temp1 ;
12919 bool created1 ;
12920 long val2 ;
12921 int ecode2 = 0 ;
12922 int val3 ;
12923 int ecode3 = 0 ;
12924 PyObject * obj0 = 0 ;
12925 PyObject * obj1 = 0 ;
12926 PyObject * obj2 = 0 ;
12927 char * kwnames[] = {
12928 (char *) "stream",(char *) "type",(char *) "index", NULL
12929 };
12930
12931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12932 {
12933 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12934 arg1 = temp1->m_wxis;
12935 created1 = false;
12936 } else {
12937 PyErr_Clear(); // clear the failure of the wxPyConvert above
12938 arg1 = wxPyCBInputStream_create(obj0, false);
12939 if (arg1 == NULL) {
12940 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12941 SWIG_fail;
12942 }
12943 created1 = true;
12944 }
12945 }
12946 if (obj1) {
12947 ecode2 = SWIG_AsVal_long(obj1, &val2);
12948 if (!SWIG_IsOK(ecode2)) {
12949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
12950 }
12951 arg2 = static_cast< long >(val2);
12952 }
12953 if (obj2) {
12954 ecode3 = SWIG_AsVal_int(obj2, &val3);
12955 if (!SWIG_IsOK(ecode3)) {
12956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
12957 }
12958 arg3 = static_cast< int >(val3);
12959 }
12960 {
12961 PyThreadState* __tstate = wxPyBeginAllowThreads();
12962 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
12963 wxPyEndAllowThreads(__tstate);
12964 if (PyErr_Occurred()) SWIG_fail;
12965 }
12966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12967 {
12968 if (created1) delete arg1;
12969 }
12970 return resultobj;
12971 fail:
12972 {
12973 if (created1) delete arg1;
12974 }
12975 return NULL;
12976 }
12977
12978
12979 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12980 PyObject *resultobj = 0;
12981 wxInputStream *arg1 = 0 ;
12982 wxString *arg2 = 0 ;
12983 int arg3 = (int) -1 ;
12984 wxImage *result = 0 ;
12985 wxPyInputStream *temp1 ;
12986 bool created1 ;
12987 bool temp2 = false ;
12988 int val3 ;
12989 int ecode3 = 0 ;
12990 PyObject * obj0 = 0 ;
12991 PyObject * obj1 = 0 ;
12992 PyObject * obj2 = 0 ;
12993 char * kwnames[] = {
12994 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
12995 };
12996
12997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12998 {
12999 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13000 arg1 = temp1->m_wxis;
13001 created1 = false;
13002 } else {
13003 PyErr_Clear(); // clear the failure of the wxPyConvert above
13004 arg1 = wxPyCBInputStream_create(obj0, false);
13005 if (arg1 == NULL) {
13006 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13007 SWIG_fail;
13008 }
13009 created1 = true;
13010 }
13011 }
13012 {
13013 arg2 = wxString_in_helper(obj1);
13014 if (arg2 == NULL) SWIG_fail;
13015 temp2 = true;
13016 }
13017 if (obj2) {
13018 ecode3 = SWIG_AsVal_int(obj2, &val3);
13019 if (!SWIG_IsOK(ecode3)) {
13020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13021 }
13022 arg3 = static_cast< int >(val3);
13023 }
13024 {
13025 PyThreadState* __tstate = wxPyBeginAllowThreads();
13026 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13027 wxPyEndAllowThreads(__tstate);
13028 if (PyErr_Occurred()) SWIG_fail;
13029 }
13030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13031 {
13032 if (created1) delete arg1;
13033 }
13034 {
13035 if (temp2)
13036 delete arg2;
13037 }
13038 return resultobj;
13039 fail:
13040 {
13041 if (created1) delete arg1;
13042 }
13043 {
13044 if (temp2)
13045 delete arg2;
13046 }
13047 return NULL;
13048 }
13049
13050
13051 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13052 PyObject *resultobj = 0;
13053 int arg1 = (int) 0 ;
13054 int arg2 = (int) 0 ;
13055 bool arg3 = (bool) true ;
13056 wxImage *result = 0 ;
13057 int val1 ;
13058 int ecode1 = 0 ;
13059 int val2 ;
13060 int ecode2 = 0 ;
13061 bool val3 ;
13062 int ecode3 = 0 ;
13063 PyObject * obj0 = 0 ;
13064 PyObject * obj1 = 0 ;
13065 PyObject * obj2 = 0 ;
13066 char * kwnames[] = {
13067 (char *) "width",(char *) "height",(char *) "clear", NULL
13068 };
13069
13070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13071 if (obj0) {
13072 ecode1 = SWIG_AsVal_int(obj0, &val1);
13073 if (!SWIG_IsOK(ecode1)) {
13074 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13075 }
13076 arg1 = static_cast< int >(val1);
13077 }
13078 if (obj1) {
13079 ecode2 = SWIG_AsVal_int(obj1, &val2);
13080 if (!SWIG_IsOK(ecode2)) {
13081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13082 }
13083 arg2 = static_cast< int >(val2);
13084 }
13085 if (obj2) {
13086 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13087 if (!SWIG_IsOK(ecode3)) {
13088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13089 }
13090 arg3 = static_cast< bool >(val3);
13091 }
13092 {
13093 PyThreadState* __tstate = wxPyBeginAllowThreads();
13094 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13095 wxPyEndAllowThreads(__tstate);
13096 if (PyErr_Occurred()) SWIG_fail;
13097 }
13098 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13099 return resultobj;
13100 fail:
13101 return NULL;
13102 }
13103
13104
13105 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13106 PyObject *resultobj = 0;
13107 wxBitmap *arg1 = 0 ;
13108 wxImage *result = 0 ;
13109 void *argp1 = 0 ;
13110 int res1 = 0 ;
13111 PyObject * obj0 = 0 ;
13112 char * kwnames[] = {
13113 (char *) "bitmap", NULL
13114 };
13115
13116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13117 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13118 if (!SWIG_IsOK(res1)) {
13119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13120 }
13121 if (!argp1) {
13122 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13123 }
13124 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13125 {
13126 if (!wxPyCheckForApp()) SWIG_fail;
13127 PyThreadState* __tstate = wxPyBeginAllowThreads();
13128 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13129 wxPyEndAllowThreads(__tstate);
13130 if (PyErr_Occurred()) SWIG_fail;
13131 }
13132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13133 return resultobj;
13134 fail:
13135 return NULL;
13136 }
13137
13138
13139 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13140 PyObject *resultobj = 0;
13141 int arg1 ;
13142 int arg2 ;
13143 buffer arg3 ;
13144 int arg4 ;
13145 wxImage *result = 0 ;
13146 int val1 ;
13147 int ecode1 = 0 ;
13148 int val2 ;
13149 int ecode2 = 0 ;
13150 PyObject * obj0 = 0 ;
13151 PyObject * obj1 = 0 ;
13152 PyObject * obj2 = 0 ;
13153 char * kwnames[] = {
13154 (char *) "width",(char *) "height",(char *) "data", NULL
13155 };
13156
13157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13158 ecode1 = SWIG_AsVal_int(obj0, &val1);
13159 if (!SWIG_IsOK(ecode1)) {
13160 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13161 }
13162 arg1 = static_cast< int >(val1);
13163 ecode2 = SWIG_AsVal_int(obj1, &val2);
13164 if (!SWIG_IsOK(ecode2)) {
13165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13166 }
13167 arg2 = static_cast< int >(val2);
13168 {
13169 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13170 }
13171 {
13172 PyThreadState* __tstate = wxPyBeginAllowThreads();
13173 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13174 wxPyEndAllowThreads(__tstate);
13175 if (PyErr_Occurred()) SWIG_fail;
13176 }
13177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13178 return resultobj;
13179 fail:
13180 return NULL;
13181 }
13182
13183
13184 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13185 PyObject *resultobj = 0;
13186 int arg1 ;
13187 int arg2 ;
13188 buffer arg3 ;
13189 int arg4 ;
13190 buffer arg5 ;
13191 int arg6 ;
13192 wxImage *result = 0 ;
13193 int val1 ;
13194 int ecode1 = 0 ;
13195 int val2 ;
13196 int ecode2 = 0 ;
13197 PyObject * obj0 = 0 ;
13198 PyObject * obj1 = 0 ;
13199 PyObject * obj2 = 0 ;
13200 PyObject * obj3 = 0 ;
13201 char * kwnames[] = {
13202 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13203 };
13204
13205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13206 ecode1 = SWIG_AsVal_int(obj0, &val1);
13207 if (!SWIG_IsOK(ecode1)) {
13208 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13209 }
13210 arg1 = static_cast< int >(val1);
13211 ecode2 = SWIG_AsVal_int(obj1, &val2);
13212 if (!SWIG_IsOK(ecode2)) {
13213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13214 }
13215 arg2 = static_cast< int >(val2);
13216 {
13217 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13218 }
13219 {
13220 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13221 }
13222 {
13223 PyThreadState* __tstate = wxPyBeginAllowThreads();
13224 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13225 wxPyEndAllowThreads(__tstate);
13226 if (PyErr_Occurred()) SWIG_fail;
13227 }
13228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13229 return resultobj;
13230 fail:
13231 return NULL;
13232 }
13233
13234
13235 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13236 PyObject *resultobj = 0;
13237 wxImage *arg1 = (wxImage *) 0 ;
13238 int arg2 ;
13239 int arg3 ;
13240 bool arg4 = (bool) true ;
13241 void *argp1 = 0 ;
13242 int res1 = 0 ;
13243 int val2 ;
13244 int ecode2 = 0 ;
13245 int val3 ;
13246 int ecode3 = 0 ;
13247 bool val4 ;
13248 int ecode4 = 0 ;
13249 PyObject * obj0 = 0 ;
13250 PyObject * obj1 = 0 ;
13251 PyObject * obj2 = 0 ;
13252 PyObject * obj3 = 0 ;
13253 char * kwnames[] = {
13254 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13255 };
13256
13257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13259 if (!SWIG_IsOK(res1)) {
13260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13261 }
13262 arg1 = reinterpret_cast< wxImage * >(argp1);
13263 ecode2 = SWIG_AsVal_int(obj1, &val2);
13264 if (!SWIG_IsOK(ecode2)) {
13265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13266 }
13267 arg2 = static_cast< int >(val2);
13268 ecode3 = SWIG_AsVal_int(obj2, &val3);
13269 if (!SWIG_IsOK(ecode3)) {
13270 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13271 }
13272 arg3 = static_cast< int >(val3);
13273 if (obj3) {
13274 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13275 if (!SWIG_IsOK(ecode4)) {
13276 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13277 }
13278 arg4 = static_cast< bool >(val4);
13279 }
13280 {
13281 PyThreadState* __tstate = wxPyBeginAllowThreads();
13282 (arg1)->Create(arg2,arg3,arg4);
13283 wxPyEndAllowThreads(__tstate);
13284 if (PyErr_Occurred()) SWIG_fail;
13285 }
13286 resultobj = SWIG_Py_Void();
13287 return resultobj;
13288 fail:
13289 return NULL;
13290 }
13291
13292
13293 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13294 PyObject *resultobj = 0;
13295 wxImage *arg1 = (wxImage *) 0 ;
13296 void *argp1 = 0 ;
13297 int res1 = 0 ;
13298 PyObject *swig_obj[1] ;
13299
13300 if (!args) SWIG_fail;
13301 swig_obj[0] = args;
13302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13303 if (!SWIG_IsOK(res1)) {
13304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13305 }
13306 arg1 = reinterpret_cast< wxImage * >(argp1);
13307 {
13308 PyThreadState* __tstate = wxPyBeginAllowThreads();
13309 (arg1)->Destroy();
13310 wxPyEndAllowThreads(__tstate);
13311 if (PyErr_Occurred()) SWIG_fail;
13312 }
13313 resultobj = SWIG_Py_Void();
13314 return resultobj;
13315 fail:
13316 return NULL;
13317 }
13318
13319
13320 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13321 PyObject *resultobj = 0;
13322 wxImage *arg1 = (wxImage *) 0 ;
13323 int arg2 ;
13324 int arg3 ;
13325 SwigValueWrapper<wxImage > result;
13326 void *argp1 = 0 ;
13327 int res1 = 0 ;
13328 int val2 ;
13329 int ecode2 = 0 ;
13330 int val3 ;
13331 int ecode3 = 0 ;
13332 PyObject * obj0 = 0 ;
13333 PyObject * obj1 = 0 ;
13334 PyObject * obj2 = 0 ;
13335 char * kwnames[] = {
13336 (char *) "self",(char *) "width",(char *) "height", NULL
13337 };
13338
13339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13341 if (!SWIG_IsOK(res1)) {
13342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13343 }
13344 arg1 = reinterpret_cast< wxImage * >(argp1);
13345 ecode2 = SWIG_AsVal_int(obj1, &val2);
13346 if (!SWIG_IsOK(ecode2)) {
13347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13348 }
13349 arg2 = static_cast< int >(val2);
13350 ecode3 = SWIG_AsVal_int(obj2, &val3);
13351 if (!SWIG_IsOK(ecode3)) {
13352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13353 }
13354 arg3 = static_cast< int >(val3);
13355 {
13356 PyThreadState* __tstate = wxPyBeginAllowThreads();
13357 result = (arg1)->Scale(arg2,arg3);
13358 wxPyEndAllowThreads(__tstate);
13359 if (PyErr_Occurred()) SWIG_fail;
13360 }
13361 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13362 return resultobj;
13363 fail:
13364 return NULL;
13365 }
13366
13367
13368 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13369 PyObject *resultobj = 0;
13370 wxImage *arg1 = (wxImage *) 0 ;
13371 int arg2 ;
13372 int arg3 ;
13373 SwigValueWrapper<wxImage > result;
13374 void *argp1 = 0 ;
13375 int res1 = 0 ;
13376 int val2 ;
13377 int ecode2 = 0 ;
13378 int val3 ;
13379 int ecode3 = 0 ;
13380 PyObject * obj0 = 0 ;
13381 PyObject * obj1 = 0 ;
13382 PyObject * obj2 = 0 ;
13383 char * kwnames[] = {
13384 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13385 };
13386
13387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13389 if (!SWIG_IsOK(res1)) {
13390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13391 }
13392 arg1 = reinterpret_cast< wxImage * >(argp1);
13393 ecode2 = SWIG_AsVal_int(obj1, &val2);
13394 if (!SWIG_IsOK(ecode2)) {
13395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13396 }
13397 arg2 = static_cast< int >(val2);
13398 ecode3 = SWIG_AsVal_int(obj2, &val3);
13399 if (!SWIG_IsOK(ecode3)) {
13400 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13401 }
13402 arg3 = static_cast< int >(val3);
13403 {
13404 PyThreadState* __tstate = wxPyBeginAllowThreads();
13405 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13406 wxPyEndAllowThreads(__tstate);
13407 if (PyErr_Occurred()) SWIG_fail;
13408 }
13409 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13410 return resultobj;
13411 fail:
13412 return NULL;
13413 }
13414
13415
13416 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13417 PyObject *resultobj = 0;
13418 wxImage *arg1 = (wxImage *) 0 ;
13419 int arg2 ;
13420 int arg3 ;
13421 wxImage *result = 0 ;
13422 void *argp1 = 0 ;
13423 int res1 = 0 ;
13424 int val2 ;
13425 int ecode2 = 0 ;
13426 int val3 ;
13427 int ecode3 = 0 ;
13428 PyObject * obj0 = 0 ;
13429 PyObject * obj1 = 0 ;
13430 PyObject * obj2 = 0 ;
13431 char * kwnames[] = {
13432 (char *) "self",(char *) "width",(char *) "height", NULL
13433 };
13434
13435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13437 if (!SWIG_IsOK(res1)) {
13438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13439 }
13440 arg1 = reinterpret_cast< wxImage * >(argp1);
13441 ecode2 = SWIG_AsVal_int(obj1, &val2);
13442 if (!SWIG_IsOK(ecode2)) {
13443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13444 }
13445 arg2 = static_cast< int >(val2);
13446 ecode3 = SWIG_AsVal_int(obj2, &val3);
13447 if (!SWIG_IsOK(ecode3)) {
13448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13449 }
13450 arg3 = static_cast< int >(val3);
13451 {
13452 PyThreadState* __tstate = wxPyBeginAllowThreads();
13453 {
13454 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13455 result = (wxImage *) &_result_ref;
13456 }
13457 wxPyEndAllowThreads(__tstate);
13458 if (PyErr_Occurred()) SWIG_fail;
13459 }
13460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13461 return resultobj;
13462 fail:
13463 return NULL;
13464 }
13465
13466
13467 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13468 PyObject *resultobj = 0;
13469 wxImage *arg1 = (wxImage *) 0 ;
13470 wxSize *arg2 = 0 ;
13471 wxPoint *arg3 = 0 ;
13472 int arg4 = (int) -1 ;
13473 int arg5 = (int) -1 ;
13474 int arg6 = (int) -1 ;
13475 wxImage *result = 0 ;
13476 void *argp1 = 0 ;
13477 int res1 = 0 ;
13478 wxSize temp2 ;
13479 wxPoint temp3 ;
13480 int val4 ;
13481 int ecode4 = 0 ;
13482 int val5 ;
13483 int ecode5 = 0 ;
13484 int val6 ;
13485 int ecode6 = 0 ;
13486 PyObject * obj0 = 0 ;
13487 PyObject * obj1 = 0 ;
13488 PyObject * obj2 = 0 ;
13489 PyObject * obj3 = 0 ;
13490 PyObject * obj4 = 0 ;
13491 PyObject * obj5 = 0 ;
13492 char * kwnames[] = {
13493 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13494 };
13495
13496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13498 if (!SWIG_IsOK(res1)) {
13499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13500 }
13501 arg1 = reinterpret_cast< wxImage * >(argp1);
13502 {
13503 arg2 = &temp2;
13504 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13505 }
13506 {
13507 arg3 = &temp3;
13508 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13509 }
13510 if (obj3) {
13511 ecode4 = SWIG_AsVal_int(obj3, &val4);
13512 if (!SWIG_IsOK(ecode4)) {
13513 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13514 }
13515 arg4 = static_cast< int >(val4);
13516 }
13517 if (obj4) {
13518 ecode5 = SWIG_AsVal_int(obj4, &val5);
13519 if (!SWIG_IsOK(ecode5)) {
13520 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13521 }
13522 arg5 = static_cast< int >(val5);
13523 }
13524 if (obj5) {
13525 ecode6 = SWIG_AsVal_int(obj5, &val6);
13526 if (!SWIG_IsOK(ecode6)) {
13527 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13528 }
13529 arg6 = static_cast< int >(val6);
13530 }
13531 {
13532 PyThreadState* __tstate = wxPyBeginAllowThreads();
13533 {
13534 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13535 result = (wxImage *) &_result_ref;
13536 }
13537 wxPyEndAllowThreads(__tstate);
13538 if (PyErr_Occurred()) SWIG_fail;
13539 }
13540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13541 return resultobj;
13542 fail:
13543 return NULL;
13544 }
13545
13546
13547 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13548 PyObject *resultobj = 0;
13549 wxImage *arg1 = (wxImage *) 0 ;
13550 int arg2 ;
13551 int arg3 ;
13552 byte arg4 ;
13553 byte arg5 ;
13554 byte arg6 ;
13555 void *argp1 = 0 ;
13556 int res1 = 0 ;
13557 int val2 ;
13558 int ecode2 = 0 ;
13559 int val3 ;
13560 int ecode3 = 0 ;
13561 unsigned char val4 ;
13562 int ecode4 = 0 ;
13563 unsigned char val5 ;
13564 int ecode5 = 0 ;
13565 unsigned char val6 ;
13566 int ecode6 = 0 ;
13567 PyObject * obj0 = 0 ;
13568 PyObject * obj1 = 0 ;
13569 PyObject * obj2 = 0 ;
13570 PyObject * obj3 = 0 ;
13571 PyObject * obj4 = 0 ;
13572 PyObject * obj5 = 0 ;
13573 char * kwnames[] = {
13574 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13575 };
13576
13577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13579 if (!SWIG_IsOK(res1)) {
13580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13581 }
13582 arg1 = reinterpret_cast< wxImage * >(argp1);
13583 ecode2 = SWIG_AsVal_int(obj1, &val2);
13584 if (!SWIG_IsOK(ecode2)) {
13585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13586 }
13587 arg2 = static_cast< int >(val2);
13588 ecode3 = SWIG_AsVal_int(obj2, &val3);
13589 if (!SWIG_IsOK(ecode3)) {
13590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13591 }
13592 arg3 = static_cast< int >(val3);
13593 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13594 if (!SWIG_IsOK(ecode4)) {
13595 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13596 }
13597 arg4 = static_cast< byte >(val4);
13598 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13599 if (!SWIG_IsOK(ecode5)) {
13600 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13601 }
13602 arg5 = static_cast< byte >(val5);
13603 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13604 if (!SWIG_IsOK(ecode6)) {
13605 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13606 }
13607 arg6 = static_cast< byte >(val6);
13608 {
13609 PyThreadState* __tstate = wxPyBeginAllowThreads();
13610 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13611 wxPyEndAllowThreads(__tstate);
13612 if (PyErr_Occurred()) SWIG_fail;
13613 }
13614 resultobj = SWIG_Py_Void();
13615 return resultobj;
13616 fail:
13617 return NULL;
13618 }
13619
13620
13621 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13622 PyObject *resultobj = 0;
13623 wxImage *arg1 = (wxImage *) 0 ;
13624 wxRect *arg2 = 0 ;
13625 byte arg3 ;
13626 byte arg4 ;
13627 byte arg5 ;
13628 void *argp1 = 0 ;
13629 int res1 = 0 ;
13630 wxRect temp2 ;
13631 unsigned char val3 ;
13632 int ecode3 = 0 ;
13633 unsigned char val4 ;
13634 int ecode4 = 0 ;
13635 unsigned char val5 ;
13636 int ecode5 = 0 ;
13637 PyObject * obj0 = 0 ;
13638 PyObject * obj1 = 0 ;
13639 PyObject * obj2 = 0 ;
13640 PyObject * obj3 = 0 ;
13641 PyObject * obj4 = 0 ;
13642 char * kwnames[] = {
13643 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13644 };
13645
13646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13648 if (!SWIG_IsOK(res1)) {
13649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13650 }
13651 arg1 = reinterpret_cast< wxImage * >(argp1);
13652 {
13653 arg2 = &temp2;
13654 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13655 }
13656 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13657 if (!SWIG_IsOK(ecode3)) {
13658 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13659 }
13660 arg3 = static_cast< byte >(val3);
13661 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13662 if (!SWIG_IsOK(ecode4)) {
13663 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13664 }
13665 arg4 = static_cast< byte >(val4);
13666 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13667 if (!SWIG_IsOK(ecode5)) {
13668 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13669 }
13670 arg5 = static_cast< byte >(val5);
13671 {
13672 PyThreadState* __tstate = wxPyBeginAllowThreads();
13673 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13674 wxPyEndAllowThreads(__tstate);
13675 if (PyErr_Occurred()) SWIG_fail;
13676 }
13677 resultobj = SWIG_Py_Void();
13678 return resultobj;
13679 fail:
13680 return NULL;
13681 }
13682
13683
13684 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13685 PyObject *resultobj = 0;
13686 wxImage *arg1 = (wxImage *) 0 ;
13687 int arg2 ;
13688 int arg3 ;
13689 byte result;
13690 void *argp1 = 0 ;
13691 int res1 = 0 ;
13692 int val2 ;
13693 int ecode2 = 0 ;
13694 int val3 ;
13695 int ecode3 = 0 ;
13696 PyObject * obj0 = 0 ;
13697 PyObject * obj1 = 0 ;
13698 PyObject * obj2 = 0 ;
13699 char * kwnames[] = {
13700 (char *) "self",(char *) "x",(char *) "y", NULL
13701 };
13702
13703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13705 if (!SWIG_IsOK(res1)) {
13706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13707 }
13708 arg1 = reinterpret_cast< wxImage * >(argp1);
13709 ecode2 = SWIG_AsVal_int(obj1, &val2);
13710 if (!SWIG_IsOK(ecode2)) {
13711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13712 }
13713 arg2 = static_cast< int >(val2);
13714 ecode3 = SWIG_AsVal_int(obj2, &val3);
13715 if (!SWIG_IsOK(ecode3)) {
13716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13717 }
13718 arg3 = static_cast< int >(val3);
13719 {
13720 PyThreadState* __tstate = wxPyBeginAllowThreads();
13721 result = (byte)(arg1)->GetRed(arg2,arg3);
13722 wxPyEndAllowThreads(__tstate);
13723 if (PyErr_Occurred()) SWIG_fail;
13724 }
13725 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13726 return resultobj;
13727 fail:
13728 return NULL;
13729 }
13730
13731
13732 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13733 PyObject *resultobj = 0;
13734 wxImage *arg1 = (wxImage *) 0 ;
13735 int arg2 ;
13736 int arg3 ;
13737 byte result;
13738 void *argp1 = 0 ;
13739 int res1 = 0 ;
13740 int val2 ;
13741 int ecode2 = 0 ;
13742 int val3 ;
13743 int ecode3 = 0 ;
13744 PyObject * obj0 = 0 ;
13745 PyObject * obj1 = 0 ;
13746 PyObject * obj2 = 0 ;
13747 char * kwnames[] = {
13748 (char *) "self",(char *) "x",(char *) "y", NULL
13749 };
13750
13751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13753 if (!SWIG_IsOK(res1)) {
13754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13755 }
13756 arg1 = reinterpret_cast< wxImage * >(argp1);
13757 ecode2 = SWIG_AsVal_int(obj1, &val2);
13758 if (!SWIG_IsOK(ecode2)) {
13759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13760 }
13761 arg2 = static_cast< int >(val2);
13762 ecode3 = SWIG_AsVal_int(obj2, &val3);
13763 if (!SWIG_IsOK(ecode3)) {
13764 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13765 }
13766 arg3 = static_cast< int >(val3);
13767 {
13768 PyThreadState* __tstate = wxPyBeginAllowThreads();
13769 result = (byte)(arg1)->GetGreen(arg2,arg3);
13770 wxPyEndAllowThreads(__tstate);
13771 if (PyErr_Occurred()) SWIG_fail;
13772 }
13773 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13774 return resultobj;
13775 fail:
13776 return NULL;
13777 }
13778
13779
13780 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13781 PyObject *resultobj = 0;
13782 wxImage *arg1 = (wxImage *) 0 ;
13783 int arg2 ;
13784 int arg3 ;
13785 byte result;
13786 void *argp1 = 0 ;
13787 int res1 = 0 ;
13788 int val2 ;
13789 int ecode2 = 0 ;
13790 int val3 ;
13791 int ecode3 = 0 ;
13792 PyObject * obj0 = 0 ;
13793 PyObject * obj1 = 0 ;
13794 PyObject * obj2 = 0 ;
13795 char * kwnames[] = {
13796 (char *) "self",(char *) "x",(char *) "y", NULL
13797 };
13798
13799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13801 if (!SWIG_IsOK(res1)) {
13802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13803 }
13804 arg1 = reinterpret_cast< wxImage * >(argp1);
13805 ecode2 = SWIG_AsVal_int(obj1, &val2);
13806 if (!SWIG_IsOK(ecode2)) {
13807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13808 }
13809 arg2 = static_cast< int >(val2);
13810 ecode3 = SWIG_AsVal_int(obj2, &val3);
13811 if (!SWIG_IsOK(ecode3)) {
13812 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13813 }
13814 arg3 = static_cast< int >(val3);
13815 {
13816 PyThreadState* __tstate = wxPyBeginAllowThreads();
13817 result = (byte)(arg1)->GetBlue(arg2,arg3);
13818 wxPyEndAllowThreads(__tstate);
13819 if (PyErr_Occurred()) SWIG_fail;
13820 }
13821 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13822 return resultobj;
13823 fail:
13824 return NULL;
13825 }
13826
13827
13828 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13829 PyObject *resultobj = 0;
13830 wxImage *arg1 = (wxImage *) 0 ;
13831 int arg2 ;
13832 int arg3 ;
13833 byte arg4 ;
13834 void *argp1 = 0 ;
13835 int res1 = 0 ;
13836 int val2 ;
13837 int ecode2 = 0 ;
13838 int val3 ;
13839 int ecode3 = 0 ;
13840 unsigned char val4 ;
13841 int ecode4 = 0 ;
13842 PyObject * obj0 = 0 ;
13843 PyObject * obj1 = 0 ;
13844 PyObject * obj2 = 0 ;
13845 PyObject * obj3 = 0 ;
13846 char * kwnames[] = {
13847 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13848 };
13849
13850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13852 if (!SWIG_IsOK(res1)) {
13853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13854 }
13855 arg1 = reinterpret_cast< wxImage * >(argp1);
13856 ecode2 = SWIG_AsVal_int(obj1, &val2);
13857 if (!SWIG_IsOK(ecode2)) {
13858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13859 }
13860 arg2 = static_cast< int >(val2);
13861 ecode3 = SWIG_AsVal_int(obj2, &val3);
13862 if (!SWIG_IsOK(ecode3)) {
13863 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13864 }
13865 arg3 = static_cast< int >(val3);
13866 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13867 if (!SWIG_IsOK(ecode4)) {
13868 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13869 }
13870 arg4 = static_cast< byte >(val4);
13871 {
13872 PyThreadState* __tstate = wxPyBeginAllowThreads();
13873 (arg1)->SetAlpha(arg2,arg3,arg4);
13874 wxPyEndAllowThreads(__tstate);
13875 if (PyErr_Occurred()) SWIG_fail;
13876 }
13877 resultobj = SWIG_Py_Void();
13878 return resultobj;
13879 fail:
13880 return NULL;
13881 }
13882
13883
13884 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13885 PyObject *resultobj = 0;
13886 wxImage *arg1 = (wxImage *) 0 ;
13887 int arg2 ;
13888 int arg3 ;
13889 byte result;
13890 void *argp1 = 0 ;
13891 int res1 = 0 ;
13892 int val2 ;
13893 int ecode2 = 0 ;
13894 int val3 ;
13895 int ecode3 = 0 ;
13896 PyObject * obj0 = 0 ;
13897 PyObject * obj1 = 0 ;
13898 PyObject * obj2 = 0 ;
13899 char * kwnames[] = {
13900 (char *) "self",(char *) "x",(char *) "y", NULL
13901 };
13902
13903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13905 if (!SWIG_IsOK(res1)) {
13906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13907 }
13908 arg1 = reinterpret_cast< wxImage * >(argp1);
13909 ecode2 = SWIG_AsVal_int(obj1, &val2);
13910 if (!SWIG_IsOK(ecode2)) {
13911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
13912 }
13913 arg2 = static_cast< int >(val2);
13914 ecode3 = SWIG_AsVal_int(obj2, &val3);
13915 if (!SWIG_IsOK(ecode3)) {
13916 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
13917 }
13918 arg3 = static_cast< int >(val3);
13919 {
13920 PyThreadState* __tstate = wxPyBeginAllowThreads();
13921 result = (byte)(arg1)->GetAlpha(arg2,arg3);
13922 wxPyEndAllowThreads(__tstate);
13923 if (PyErr_Occurred()) SWIG_fail;
13924 }
13925 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13926 return resultobj;
13927 fail:
13928 return NULL;
13929 }
13930
13931
13932 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13933 PyObject *resultobj = 0;
13934 wxImage *arg1 = (wxImage *) 0 ;
13935 bool result;
13936 void *argp1 = 0 ;
13937 int res1 = 0 ;
13938 PyObject *swig_obj[1] ;
13939
13940 if (!args) SWIG_fail;
13941 swig_obj[0] = args;
13942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13943 if (!SWIG_IsOK(res1)) {
13944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13945 }
13946 arg1 = reinterpret_cast< wxImage * >(argp1);
13947 {
13948 PyThreadState* __tstate = wxPyBeginAllowThreads();
13949 result = (bool)(arg1)->HasAlpha();
13950 wxPyEndAllowThreads(__tstate);
13951 if (PyErr_Occurred()) SWIG_fail;
13952 }
13953 {
13954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13955 }
13956 return resultobj;
13957 fail:
13958 return NULL;
13959 }
13960
13961
13962 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13963 PyObject *resultobj = 0;
13964 wxImage *arg1 = (wxImage *) 0 ;
13965 void *argp1 = 0 ;
13966 int res1 = 0 ;
13967 PyObject *swig_obj[1] ;
13968
13969 if (!args) SWIG_fail;
13970 swig_obj[0] = args;
13971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13972 if (!SWIG_IsOK(res1)) {
13973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13974 }
13975 arg1 = reinterpret_cast< wxImage * >(argp1);
13976 {
13977 PyThreadState* __tstate = wxPyBeginAllowThreads();
13978 (arg1)->InitAlpha();
13979 wxPyEndAllowThreads(__tstate);
13980 if (PyErr_Occurred()) SWIG_fail;
13981 }
13982 resultobj = SWIG_Py_Void();
13983 return resultobj;
13984 fail:
13985 return NULL;
13986 }
13987
13988
13989 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13990 PyObject *resultobj = 0;
13991 wxImage *arg1 = (wxImage *) 0 ;
13992 int arg2 ;
13993 int arg3 ;
13994 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
13995 bool result;
13996 void *argp1 = 0 ;
13997 int res1 = 0 ;
13998 int val2 ;
13999 int ecode2 = 0 ;
14000 int val3 ;
14001 int ecode3 = 0 ;
14002 unsigned char val4 ;
14003 int ecode4 = 0 ;
14004 PyObject * obj0 = 0 ;
14005 PyObject * obj1 = 0 ;
14006 PyObject * obj2 = 0 ;
14007 PyObject * obj3 = 0 ;
14008 char * kwnames[] = {
14009 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14010 };
14011
14012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14014 if (!SWIG_IsOK(res1)) {
14015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14016 }
14017 arg1 = reinterpret_cast< wxImage * >(argp1);
14018 ecode2 = SWIG_AsVal_int(obj1, &val2);
14019 if (!SWIG_IsOK(ecode2)) {
14020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14021 }
14022 arg2 = static_cast< int >(val2);
14023 ecode3 = SWIG_AsVal_int(obj2, &val3);
14024 if (!SWIG_IsOK(ecode3)) {
14025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14026 }
14027 arg3 = static_cast< int >(val3);
14028 if (obj3) {
14029 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14030 if (!SWIG_IsOK(ecode4)) {
14031 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14032 }
14033 arg4 = static_cast< byte >(val4);
14034 }
14035 {
14036 PyThreadState* __tstate = wxPyBeginAllowThreads();
14037 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14038 wxPyEndAllowThreads(__tstate);
14039 if (PyErr_Occurred()) SWIG_fail;
14040 }
14041 {
14042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14043 }
14044 return resultobj;
14045 fail:
14046 return NULL;
14047 }
14048
14049
14050 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14051 PyObject *resultobj = 0;
14052 wxImage *arg1 = (wxImage *) 0 ;
14053 byte *arg2 = (byte *) 0 ;
14054 byte *arg3 = (byte *) 0 ;
14055 byte *arg4 = (byte *) 0 ;
14056 byte arg5 = (byte) 0 ;
14057 byte arg6 = (byte) 0 ;
14058 byte arg7 = (byte) 0 ;
14059 bool result;
14060 void *argp1 = 0 ;
14061 int res1 = 0 ;
14062 byte temp2 ;
14063 int res2 = SWIG_TMPOBJ ;
14064 byte temp3 ;
14065 int res3 = SWIG_TMPOBJ ;
14066 byte temp4 ;
14067 int res4 = SWIG_TMPOBJ ;
14068 unsigned char val5 ;
14069 int ecode5 = 0 ;
14070 unsigned char val6 ;
14071 int ecode6 = 0 ;
14072 unsigned char val7 ;
14073 int ecode7 = 0 ;
14074 PyObject * obj0 = 0 ;
14075 PyObject * obj1 = 0 ;
14076 PyObject * obj2 = 0 ;
14077 PyObject * obj3 = 0 ;
14078 char * kwnames[] = {
14079 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14080 };
14081
14082 arg2 = &temp2;
14083 arg3 = &temp3;
14084 arg4 = &temp4;
14085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14087 if (!SWIG_IsOK(res1)) {
14088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14089 }
14090 arg1 = reinterpret_cast< wxImage * >(argp1);
14091 if (obj1) {
14092 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14093 if (!SWIG_IsOK(ecode5)) {
14094 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14095 }
14096 arg5 = static_cast< byte >(val5);
14097 }
14098 if (obj2) {
14099 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14100 if (!SWIG_IsOK(ecode6)) {
14101 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14102 }
14103 arg6 = static_cast< byte >(val6);
14104 }
14105 if (obj3) {
14106 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14107 if (!SWIG_IsOK(ecode7)) {
14108 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14109 }
14110 arg7 = static_cast< byte >(val7);
14111 }
14112 {
14113 PyThreadState* __tstate = wxPyBeginAllowThreads();
14114 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14115 wxPyEndAllowThreads(__tstate);
14116 if (PyErr_Occurred()) SWIG_fail;
14117 }
14118 {
14119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14120 }
14121 if (SWIG_IsTmpObj(res2)) {
14122 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14123 } else {
14124 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14125 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14126 }
14127 if (SWIG_IsTmpObj(res3)) {
14128 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14129 } else {
14130 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14131 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14132 }
14133 if (SWIG_IsTmpObj(res4)) {
14134 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14135 } else {
14136 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14137 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14138 }
14139 return resultobj;
14140 fail:
14141 return NULL;
14142 }
14143
14144
14145 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14146 PyObject *resultobj = 0;
14147 wxImage *arg1 = (wxImage *) 0 ;
14148 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14149 bool result;
14150 void *argp1 = 0 ;
14151 int res1 = 0 ;
14152 unsigned char val2 ;
14153 int ecode2 = 0 ;
14154 PyObject * obj0 = 0 ;
14155 PyObject * obj1 = 0 ;
14156 char * kwnames[] = {
14157 (char *) "self",(char *) "threshold", NULL
14158 };
14159
14160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14162 if (!SWIG_IsOK(res1)) {
14163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14164 }
14165 arg1 = reinterpret_cast< wxImage * >(argp1);
14166 if (obj1) {
14167 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14168 if (!SWIG_IsOK(ecode2)) {
14169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14170 }
14171 arg2 = static_cast< byte >(val2);
14172 }
14173 {
14174 PyThreadState* __tstate = wxPyBeginAllowThreads();
14175 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14176 wxPyEndAllowThreads(__tstate);
14177 if (PyErr_Occurred()) SWIG_fail;
14178 }
14179 {
14180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14181 }
14182 return resultobj;
14183 fail:
14184 return NULL;
14185 }
14186
14187
14188 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14189 PyObject *resultobj = 0;
14190 wxImage *arg1 = (wxImage *) 0 ;
14191 byte arg2 ;
14192 byte arg3 ;
14193 byte arg4 ;
14194 bool result;
14195 void *argp1 = 0 ;
14196 int res1 = 0 ;
14197 unsigned char val2 ;
14198 int ecode2 = 0 ;
14199 unsigned char val3 ;
14200 int ecode3 = 0 ;
14201 unsigned char val4 ;
14202 int ecode4 = 0 ;
14203 PyObject * obj0 = 0 ;
14204 PyObject * obj1 = 0 ;
14205 PyObject * obj2 = 0 ;
14206 PyObject * obj3 = 0 ;
14207 char * kwnames[] = {
14208 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14209 };
14210
14211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14213 if (!SWIG_IsOK(res1)) {
14214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14215 }
14216 arg1 = reinterpret_cast< wxImage * >(argp1);
14217 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14218 if (!SWIG_IsOK(ecode2)) {
14219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14220 }
14221 arg2 = static_cast< byte >(val2);
14222 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14223 if (!SWIG_IsOK(ecode3)) {
14224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14225 }
14226 arg3 = static_cast< byte >(val3);
14227 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14228 if (!SWIG_IsOK(ecode4)) {
14229 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14230 }
14231 arg4 = static_cast< byte >(val4);
14232 {
14233 PyThreadState* __tstate = wxPyBeginAllowThreads();
14234 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14235 wxPyEndAllowThreads(__tstate);
14236 if (PyErr_Occurred()) SWIG_fail;
14237 }
14238 {
14239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14240 }
14241 return resultobj;
14242 fail:
14243 return NULL;
14244 }
14245
14246
14247 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14248 PyObject *resultobj = 0;
14249 wxImage *arg1 = (wxImage *) 0 ;
14250 wxImage *arg2 = 0 ;
14251 byte arg3 ;
14252 byte arg4 ;
14253 byte arg5 ;
14254 bool result;
14255 void *argp1 = 0 ;
14256 int res1 = 0 ;
14257 void *argp2 = 0 ;
14258 int res2 = 0 ;
14259 unsigned char val3 ;
14260 int ecode3 = 0 ;
14261 unsigned char val4 ;
14262 int ecode4 = 0 ;
14263 unsigned char val5 ;
14264 int ecode5 = 0 ;
14265 PyObject * obj0 = 0 ;
14266 PyObject * obj1 = 0 ;
14267 PyObject * obj2 = 0 ;
14268 PyObject * obj3 = 0 ;
14269 PyObject * obj4 = 0 ;
14270 char * kwnames[] = {
14271 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14272 };
14273
14274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14276 if (!SWIG_IsOK(res1)) {
14277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14278 }
14279 arg1 = reinterpret_cast< wxImage * >(argp1);
14280 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14281 if (!SWIG_IsOK(res2)) {
14282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14283 }
14284 if (!argp2) {
14285 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14286 }
14287 arg2 = reinterpret_cast< wxImage * >(argp2);
14288 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14289 if (!SWIG_IsOK(ecode3)) {
14290 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14291 }
14292 arg3 = static_cast< byte >(val3);
14293 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14294 if (!SWIG_IsOK(ecode4)) {
14295 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14296 }
14297 arg4 = static_cast< byte >(val4);
14298 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14299 if (!SWIG_IsOK(ecode5)) {
14300 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14301 }
14302 arg5 = static_cast< byte >(val5);
14303 {
14304 PyThreadState* __tstate = wxPyBeginAllowThreads();
14305 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14306 wxPyEndAllowThreads(__tstate);
14307 if (PyErr_Occurred()) SWIG_fail;
14308 }
14309 {
14310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14311 }
14312 return resultobj;
14313 fail:
14314 return NULL;
14315 }
14316
14317
14318 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14319 PyObject *resultobj = 0;
14320 wxString *arg1 = 0 ;
14321 bool result;
14322 bool temp1 = false ;
14323 PyObject * obj0 = 0 ;
14324 char * kwnames[] = {
14325 (char *) "filename", NULL
14326 };
14327
14328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14329 {
14330 arg1 = wxString_in_helper(obj0);
14331 if (arg1 == NULL) SWIG_fail;
14332 temp1 = true;
14333 }
14334 {
14335 PyThreadState* __tstate = wxPyBeginAllowThreads();
14336 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14337 wxPyEndAllowThreads(__tstate);
14338 if (PyErr_Occurred()) SWIG_fail;
14339 }
14340 {
14341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14342 }
14343 {
14344 if (temp1)
14345 delete arg1;
14346 }
14347 return resultobj;
14348 fail:
14349 {
14350 if (temp1)
14351 delete arg1;
14352 }
14353 return NULL;
14354 }
14355
14356
14357 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14358 PyObject *resultobj = 0;
14359 wxString *arg1 = 0 ;
14360 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14361 int result;
14362 bool temp1 = false ;
14363 long val2 ;
14364 int ecode2 = 0 ;
14365 PyObject * obj0 = 0 ;
14366 PyObject * obj1 = 0 ;
14367 char * kwnames[] = {
14368 (char *) "filename",(char *) "type", NULL
14369 };
14370
14371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14372 {
14373 arg1 = wxString_in_helper(obj0);
14374 if (arg1 == NULL) SWIG_fail;
14375 temp1 = true;
14376 }
14377 if (obj1) {
14378 ecode2 = SWIG_AsVal_long(obj1, &val2);
14379 if (!SWIG_IsOK(ecode2)) {
14380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14381 }
14382 arg2 = static_cast< long >(val2);
14383 }
14384 {
14385 PyThreadState* __tstate = wxPyBeginAllowThreads();
14386 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14387 wxPyEndAllowThreads(__tstate);
14388 if (PyErr_Occurred()) SWIG_fail;
14389 }
14390 resultobj = SWIG_From_int(static_cast< int >(result));
14391 {
14392 if (temp1)
14393 delete arg1;
14394 }
14395 return resultobj;
14396 fail:
14397 {
14398 if (temp1)
14399 delete arg1;
14400 }
14401 return NULL;
14402 }
14403
14404
14405 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14406 PyObject *resultobj = 0;
14407 wxImage *arg1 = (wxImage *) 0 ;
14408 wxString *arg2 = 0 ;
14409 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14410 int arg4 = (int) -1 ;
14411 bool result;
14412 void *argp1 = 0 ;
14413 int res1 = 0 ;
14414 bool temp2 = false ;
14415 long val3 ;
14416 int ecode3 = 0 ;
14417 int val4 ;
14418 int ecode4 = 0 ;
14419 PyObject * obj0 = 0 ;
14420 PyObject * obj1 = 0 ;
14421 PyObject * obj2 = 0 ;
14422 PyObject * obj3 = 0 ;
14423 char * kwnames[] = {
14424 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14425 };
14426
14427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14429 if (!SWIG_IsOK(res1)) {
14430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14431 }
14432 arg1 = reinterpret_cast< wxImage * >(argp1);
14433 {
14434 arg2 = wxString_in_helper(obj1);
14435 if (arg2 == NULL) SWIG_fail;
14436 temp2 = true;
14437 }
14438 if (obj2) {
14439 ecode3 = SWIG_AsVal_long(obj2, &val3);
14440 if (!SWIG_IsOK(ecode3)) {
14441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14442 }
14443 arg3 = static_cast< long >(val3);
14444 }
14445 if (obj3) {
14446 ecode4 = SWIG_AsVal_int(obj3, &val4);
14447 if (!SWIG_IsOK(ecode4)) {
14448 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14449 }
14450 arg4 = static_cast< int >(val4);
14451 }
14452 {
14453 PyThreadState* __tstate = wxPyBeginAllowThreads();
14454 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14455 wxPyEndAllowThreads(__tstate);
14456 if (PyErr_Occurred()) SWIG_fail;
14457 }
14458 {
14459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14460 }
14461 {
14462 if (temp2)
14463 delete arg2;
14464 }
14465 return resultobj;
14466 fail:
14467 {
14468 if (temp2)
14469 delete arg2;
14470 }
14471 return NULL;
14472 }
14473
14474
14475 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14476 PyObject *resultobj = 0;
14477 wxImage *arg1 = (wxImage *) 0 ;
14478 wxString *arg2 = 0 ;
14479 wxString *arg3 = 0 ;
14480 int arg4 = (int) -1 ;
14481 bool result;
14482 void *argp1 = 0 ;
14483 int res1 = 0 ;
14484 bool temp2 = false ;
14485 bool temp3 = false ;
14486 int val4 ;
14487 int ecode4 = 0 ;
14488 PyObject * obj0 = 0 ;
14489 PyObject * obj1 = 0 ;
14490 PyObject * obj2 = 0 ;
14491 PyObject * obj3 = 0 ;
14492 char * kwnames[] = {
14493 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14494 };
14495
14496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14498 if (!SWIG_IsOK(res1)) {
14499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14500 }
14501 arg1 = reinterpret_cast< wxImage * >(argp1);
14502 {
14503 arg2 = wxString_in_helper(obj1);
14504 if (arg2 == NULL) SWIG_fail;
14505 temp2 = true;
14506 }
14507 {
14508 arg3 = wxString_in_helper(obj2);
14509 if (arg3 == NULL) SWIG_fail;
14510 temp3 = true;
14511 }
14512 if (obj3) {
14513 ecode4 = SWIG_AsVal_int(obj3, &val4);
14514 if (!SWIG_IsOK(ecode4)) {
14515 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14516 }
14517 arg4 = static_cast< int >(val4);
14518 }
14519 {
14520 PyThreadState* __tstate = wxPyBeginAllowThreads();
14521 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14522 wxPyEndAllowThreads(__tstate);
14523 if (PyErr_Occurred()) SWIG_fail;
14524 }
14525 {
14526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14527 }
14528 {
14529 if (temp2)
14530 delete arg2;
14531 }
14532 {
14533 if (temp3)
14534 delete arg3;
14535 }
14536 return resultobj;
14537 fail:
14538 {
14539 if (temp2)
14540 delete arg2;
14541 }
14542 {
14543 if (temp3)
14544 delete arg3;
14545 }
14546 return NULL;
14547 }
14548
14549
14550 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14551 PyObject *resultobj = 0;
14552 wxImage *arg1 = (wxImage *) 0 ;
14553 wxString *arg2 = 0 ;
14554 int arg3 ;
14555 bool result;
14556 void *argp1 = 0 ;
14557 int res1 = 0 ;
14558 bool temp2 = false ;
14559 int val3 ;
14560 int ecode3 = 0 ;
14561 PyObject * obj0 = 0 ;
14562 PyObject * obj1 = 0 ;
14563 PyObject * obj2 = 0 ;
14564 char * kwnames[] = {
14565 (char *) "self",(char *) "name",(char *) "type", NULL
14566 };
14567
14568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14570 if (!SWIG_IsOK(res1)) {
14571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14572 }
14573 arg1 = reinterpret_cast< wxImage * >(argp1);
14574 {
14575 arg2 = wxString_in_helper(obj1);
14576 if (arg2 == NULL) SWIG_fail;
14577 temp2 = true;
14578 }
14579 ecode3 = SWIG_AsVal_int(obj2, &val3);
14580 if (!SWIG_IsOK(ecode3)) {
14581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14582 }
14583 arg3 = static_cast< int >(val3);
14584 {
14585 PyThreadState* __tstate = wxPyBeginAllowThreads();
14586 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14587 wxPyEndAllowThreads(__tstate);
14588 if (PyErr_Occurred()) SWIG_fail;
14589 }
14590 {
14591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14592 }
14593 {
14594 if (temp2)
14595 delete arg2;
14596 }
14597 return resultobj;
14598 fail:
14599 {
14600 if (temp2)
14601 delete arg2;
14602 }
14603 return NULL;
14604 }
14605
14606
14607 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14608 PyObject *resultobj = 0;
14609 wxImage *arg1 = (wxImage *) 0 ;
14610 wxString *arg2 = 0 ;
14611 wxString *arg3 = 0 ;
14612 bool result;
14613 void *argp1 = 0 ;
14614 int res1 = 0 ;
14615 bool temp2 = false ;
14616 bool temp3 = false ;
14617 PyObject * obj0 = 0 ;
14618 PyObject * obj1 = 0 ;
14619 PyObject * obj2 = 0 ;
14620 char * kwnames[] = {
14621 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14622 };
14623
14624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14626 if (!SWIG_IsOK(res1)) {
14627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14628 }
14629 arg1 = reinterpret_cast< wxImage * >(argp1);
14630 {
14631 arg2 = wxString_in_helper(obj1);
14632 if (arg2 == NULL) SWIG_fail;
14633 temp2 = true;
14634 }
14635 {
14636 arg3 = wxString_in_helper(obj2);
14637 if (arg3 == NULL) SWIG_fail;
14638 temp3 = true;
14639 }
14640 {
14641 PyThreadState* __tstate = wxPyBeginAllowThreads();
14642 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14643 wxPyEndAllowThreads(__tstate);
14644 if (PyErr_Occurred()) SWIG_fail;
14645 }
14646 {
14647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14648 }
14649 {
14650 if (temp2)
14651 delete arg2;
14652 }
14653 {
14654 if (temp3)
14655 delete arg3;
14656 }
14657 return resultobj;
14658 fail:
14659 {
14660 if (temp2)
14661 delete arg2;
14662 }
14663 {
14664 if (temp3)
14665 delete arg3;
14666 }
14667 return NULL;
14668 }
14669
14670
14671 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14672 PyObject *resultobj = 0;
14673 wxInputStream *arg1 = 0 ;
14674 bool result;
14675 wxPyInputStream *temp1 ;
14676 bool created1 ;
14677 PyObject * obj0 = 0 ;
14678 char * kwnames[] = {
14679 (char *) "stream", NULL
14680 };
14681
14682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14683 {
14684 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14685 arg1 = temp1->m_wxis;
14686 created1 = false;
14687 } else {
14688 PyErr_Clear(); // clear the failure of the wxPyConvert above
14689 arg1 = wxPyCBInputStream_create(obj0, false);
14690 if (arg1 == NULL) {
14691 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14692 SWIG_fail;
14693 }
14694 created1 = true;
14695 }
14696 }
14697 {
14698 PyThreadState* __tstate = wxPyBeginAllowThreads();
14699 result = (bool)wxImage::CanRead(*arg1);
14700 wxPyEndAllowThreads(__tstate);
14701 if (PyErr_Occurred()) SWIG_fail;
14702 }
14703 {
14704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14705 }
14706 {
14707 if (created1) delete arg1;
14708 }
14709 return resultobj;
14710 fail:
14711 {
14712 if (created1) delete arg1;
14713 }
14714 return NULL;
14715 }
14716
14717
14718 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14719 PyObject *resultobj = 0;
14720 wxImage *arg1 = (wxImage *) 0 ;
14721 wxInputStream *arg2 = 0 ;
14722 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14723 int arg4 = (int) -1 ;
14724 bool result;
14725 void *argp1 = 0 ;
14726 int res1 = 0 ;
14727 wxPyInputStream *temp2 ;
14728 bool created2 ;
14729 long val3 ;
14730 int ecode3 = 0 ;
14731 int val4 ;
14732 int ecode4 = 0 ;
14733 PyObject * obj0 = 0 ;
14734 PyObject * obj1 = 0 ;
14735 PyObject * obj2 = 0 ;
14736 PyObject * obj3 = 0 ;
14737 char * kwnames[] = {
14738 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14739 };
14740
14741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14743 if (!SWIG_IsOK(res1)) {
14744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14745 }
14746 arg1 = reinterpret_cast< wxImage * >(argp1);
14747 {
14748 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14749 arg2 = temp2->m_wxis;
14750 created2 = false;
14751 } else {
14752 PyErr_Clear(); // clear the failure of the wxPyConvert above
14753 arg2 = wxPyCBInputStream_create(obj1, false);
14754 if (arg2 == NULL) {
14755 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14756 SWIG_fail;
14757 }
14758 created2 = true;
14759 }
14760 }
14761 if (obj2) {
14762 ecode3 = SWIG_AsVal_long(obj2, &val3);
14763 if (!SWIG_IsOK(ecode3)) {
14764 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14765 }
14766 arg3 = static_cast< long >(val3);
14767 }
14768 if (obj3) {
14769 ecode4 = SWIG_AsVal_int(obj3, &val4);
14770 if (!SWIG_IsOK(ecode4)) {
14771 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14772 }
14773 arg4 = static_cast< int >(val4);
14774 }
14775 {
14776 PyThreadState* __tstate = wxPyBeginAllowThreads();
14777 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14778 wxPyEndAllowThreads(__tstate);
14779 if (PyErr_Occurred()) SWIG_fail;
14780 }
14781 {
14782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14783 }
14784 {
14785 if (created2) delete arg2;
14786 }
14787 return resultobj;
14788 fail:
14789 {
14790 if (created2) delete arg2;
14791 }
14792 return NULL;
14793 }
14794
14795
14796 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14797 PyObject *resultobj = 0;
14798 wxImage *arg1 = (wxImage *) 0 ;
14799 wxInputStream *arg2 = 0 ;
14800 wxString *arg3 = 0 ;
14801 int arg4 = (int) -1 ;
14802 bool result;
14803 void *argp1 = 0 ;
14804 int res1 = 0 ;
14805 wxPyInputStream *temp2 ;
14806 bool created2 ;
14807 bool temp3 = false ;
14808 int val4 ;
14809 int ecode4 = 0 ;
14810 PyObject * obj0 = 0 ;
14811 PyObject * obj1 = 0 ;
14812 PyObject * obj2 = 0 ;
14813 PyObject * obj3 = 0 ;
14814 char * kwnames[] = {
14815 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14816 };
14817
14818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14820 if (!SWIG_IsOK(res1)) {
14821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14822 }
14823 arg1 = reinterpret_cast< wxImage * >(argp1);
14824 {
14825 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14826 arg2 = temp2->m_wxis;
14827 created2 = false;
14828 } else {
14829 PyErr_Clear(); // clear the failure of the wxPyConvert above
14830 arg2 = wxPyCBInputStream_create(obj1, false);
14831 if (arg2 == NULL) {
14832 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14833 SWIG_fail;
14834 }
14835 created2 = true;
14836 }
14837 }
14838 {
14839 arg3 = wxString_in_helper(obj2);
14840 if (arg3 == NULL) SWIG_fail;
14841 temp3 = true;
14842 }
14843 if (obj3) {
14844 ecode4 = SWIG_AsVal_int(obj3, &val4);
14845 if (!SWIG_IsOK(ecode4)) {
14846 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14847 }
14848 arg4 = static_cast< int >(val4);
14849 }
14850 {
14851 PyThreadState* __tstate = wxPyBeginAllowThreads();
14852 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14853 wxPyEndAllowThreads(__tstate);
14854 if (PyErr_Occurred()) SWIG_fail;
14855 }
14856 {
14857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14858 }
14859 {
14860 if (created2) delete arg2;
14861 }
14862 {
14863 if (temp3)
14864 delete arg3;
14865 }
14866 return resultobj;
14867 fail:
14868 {
14869 if (created2) delete arg2;
14870 }
14871 {
14872 if (temp3)
14873 delete arg3;
14874 }
14875 return NULL;
14876 }
14877
14878
14879 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14880 PyObject *resultobj = 0;
14881 wxImage *arg1 = (wxImage *) 0 ;
14882 bool result;
14883 void *argp1 = 0 ;
14884 int res1 = 0 ;
14885 PyObject *swig_obj[1] ;
14886
14887 if (!args) SWIG_fail;
14888 swig_obj[0] = args;
14889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14890 if (!SWIG_IsOK(res1)) {
14891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14892 }
14893 arg1 = reinterpret_cast< wxImage * >(argp1);
14894 {
14895 PyThreadState* __tstate = wxPyBeginAllowThreads();
14896 result = (bool)(arg1)->Ok();
14897 wxPyEndAllowThreads(__tstate);
14898 if (PyErr_Occurred()) SWIG_fail;
14899 }
14900 {
14901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14902 }
14903 return resultobj;
14904 fail:
14905 return NULL;
14906 }
14907
14908
14909 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14910 PyObject *resultobj = 0;
14911 wxImage *arg1 = (wxImage *) 0 ;
14912 int result;
14913 void *argp1 = 0 ;
14914 int res1 = 0 ;
14915 PyObject *swig_obj[1] ;
14916
14917 if (!args) SWIG_fail;
14918 swig_obj[0] = args;
14919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14920 if (!SWIG_IsOK(res1)) {
14921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
14922 }
14923 arg1 = reinterpret_cast< wxImage * >(argp1);
14924 {
14925 PyThreadState* __tstate = wxPyBeginAllowThreads();
14926 result = (int)(arg1)->GetWidth();
14927 wxPyEndAllowThreads(__tstate);
14928 if (PyErr_Occurred()) SWIG_fail;
14929 }
14930 resultobj = SWIG_From_int(static_cast< int >(result));
14931 return resultobj;
14932 fail:
14933 return NULL;
14934 }
14935
14936
14937 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14938 PyObject *resultobj = 0;
14939 wxImage *arg1 = (wxImage *) 0 ;
14940 int result;
14941 void *argp1 = 0 ;
14942 int res1 = 0 ;
14943 PyObject *swig_obj[1] ;
14944
14945 if (!args) SWIG_fail;
14946 swig_obj[0] = args;
14947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14948 if (!SWIG_IsOK(res1)) {
14949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
14950 }
14951 arg1 = reinterpret_cast< wxImage * >(argp1);
14952 {
14953 PyThreadState* __tstate = wxPyBeginAllowThreads();
14954 result = (int)(arg1)->GetHeight();
14955 wxPyEndAllowThreads(__tstate);
14956 if (PyErr_Occurred()) SWIG_fail;
14957 }
14958 resultobj = SWIG_From_int(static_cast< int >(result));
14959 return resultobj;
14960 fail:
14961 return NULL;
14962 }
14963
14964
14965 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14966 PyObject *resultobj = 0;
14967 wxImage *arg1 = (wxImage *) 0 ;
14968 wxSize result;
14969 void *argp1 = 0 ;
14970 int res1 = 0 ;
14971 PyObject *swig_obj[1] ;
14972
14973 if (!args) SWIG_fail;
14974 swig_obj[0] = args;
14975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14976 if (!SWIG_IsOK(res1)) {
14977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
14978 }
14979 arg1 = reinterpret_cast< wxImage * >(argp1);
14980 {
14981 PyThreadState* __tstate = wxPyBeginAllowThreads();
14982 result = wxImage_GetSize(arg1);
14983 wxPyEndAllowThreads(__tstate);
14984 if (PyErr_Occurred()) SWIG_fail;
14985 }
14986 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
14987 return resultobj;
14988 fail:
14989 return NULL;
14990 }
14991
14992
14993 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14994 PyObject *resultobj = 0;
14995 wxImage *arg1 = (wxImage *) 0 ;
14996 wxRect *arg2 = 0 ;
14997 SwigValueWrapper<wxImage > result;
14998 void *argp1 = 0 ;
14999 int res1 = 0 ;
15000 wxRect temp2 ;
15001 PyObject * obj0 = 0 ;
15002 PyObject * obj1 = 0 ;
15003 char * kwnames[] = {
15004 (char *) "self",(char *) "rect", NULL
15005 };
15006
15007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15009 if (!SWIG_IsOK(res1)) {
15010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15011 }
15012 arg1 = reinterpret_cast< wxImage * >(argp1);
15013 {
15014 arg2 = &temp2;
15015 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15016 }
15017 {
15018 PyThreadState* __tstate = wxPyBeginAllowThreads();
15019 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15020 wxPyEndAllowThreads(__tstate);
15021 if (PyErr_Occurred()) SWIG_fail;
15022 }
15023 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15024 return resultobj;
15025 fail:
15026 return NULL;
15027 }
15028
15029
15030 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15031 PyObject *resultobj = 0;
15032 wxImage *arg1 = (wxImage *) 0 ;
15033 wxSize *arg2 = 0 ;
15034 wxPoint *arg3 = 0 ;
15035 int arg4 = (int) -1 ;
15036 int arg5 = (int) -1 ;
15037 int arg6 = (int) -1 ;
15038 SwigValueWrapper<wxImage > result;
15039 void *argp1 = 0 ;
15040 int res1 = 0 ;
15041 wxSize temp2 ;
15042 wxPoint temp3 ;
15043 int val4 ;
15044 int ecode4 = 0 ;
15045 int val5 ;
15046 int ecode5 = 0 ;
15047 int val6 ;
15048 int ecode6 = 0 ;
15049 PyObject * obj0 = 0 ;
15050 PyObject * obj1 = 0 ;
15051 PyObject * obj2 = 0 ;
15052 PyObject * obj3 = 0 ;
15053 PyObject * obj4 = 0 ;
15054 PyObject * obj5 = 0 ;
15055 char * kwnames[] = {
15056 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15057 };
15058
15059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15061 if (!SWIG_IsOK(res1)) {
15062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15063 }
15064 arg1 = reinterpret_cast< wxImage * >(argp1);
15065 {
15066 arg2 = &temp2;
15067 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15068 }
15069 {
15070 arg3 = &temp3;
15071 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15072 }
15073 if (obj3) {
15074 ecode4 = SWIG_AsVal_int(obj3, &val4);
15075 if (!SWIG_IsOK(ecode4)) {
15076 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15077 }
15078 arg4 = static_cast< int >(val4);
15079 }
15080 if (obj4) {
15081 ecode5 = SWIG_AsVal_int(obj4, &val5);
15082 if (!SWIG_IsOK(ecode5)) {
15083 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15084 }
15085 arg5 = static_cast< int >(val5);
15086 }
15087 if (obj5) {
15088 ecode6 = SWIG_AsVal_int(obj5, &val6);
15089 if (!SWIG_IsOK(ecode6)) {
15090 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15091 }
15092 arg6 = static_cast< int >(val6);
15093 }
15094 {
15095 PyThreadState* __tstate = wxPyBeginAllowThreads();
15096 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15097 wxPyEndAllowThreads(__tstate);
15098 if (PyErr_Occurred()) SWIG_fail;
15099 }
15100 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15101 return resultobj;
15102 fail:
15103 return NULL;
15104 }
15105
15106
15107 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15108 PyObject *resultobj = 0;
15109 wxImage *arg1 = (wxImage *) 0 ;
15110 SwigValueWrapper<wxImage > result;
15111 void *argp1 = 0 ;
15112 int res1 = 0 ;
15113 PyObject *swig_obj[1] ;
15114
15115 if (!args) SWIG_fail;
15116 swig_obj[0] = args;
15117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15118 if (!SWIG_IsOK(res1)) {
15119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15120 }
15121 arg1 = reinterpret_cast< wxImage * >(argp1);
15122 {
15123 PyThreadState* __tstate = wxPyBeginAllowThreads();
15124 result = (arg1)->Copy();
15125 wxPyEndAllowThreads(__tstate);
15126 if (PyErr_Occurred()) SWIG_fail;
15127 }
15128 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15129 return resultobj;
15130 fail:
15131 return NULL;
15132 }
15133
15134
15135 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15136 PyObject *resultobj = 0;
15137 wxImage *arg1 = (wxImage *) 0 ;
15138 wxImage *arg2 = 0 ;
15139 int arg3 ;
15140 int arg4 ;
15141 void *argp1 = 0 ;
15142 int res1 = 0 ;
15143 void *argp2 = 0 ;
15144 int res2 = 0 ;
15145 int val3 ;
15146 int ecode3 = 0 ;
15147 int val4 ;
15148 int ecode4 = 0 ;
15149 PyObject * obj0 = 0 ;
15150 PyObject * obj1 = 0 ;
15151 PyObject * obj2 = 0 ;
15152 PyObject * obj3 = 0 ;
15153 char * kwnames[] = {
15154 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15155 };
15156
15157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15159 if (!SWIG_IsOK(res1)) {
15160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15161 }
15162 arg1 = reinterpret_cast< wxImage * >(argp1);
15163 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15164 if (!SWIG_IsOK(res2)) {
15165 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15166 }
15167 if (!argp2) {
15168 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15169 }
15170 arg2 = reinterpret_cast< wxImage * >(argp2);
15171 ecode3 = SWIG_AsVal_int(obj2, &val3);
15172 if (!SWIG_IsOK(ecode3)) {
15173 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15174 }
15175 arg3 = static_cast< int >(val3);
15176 ecode4 = SWIG_AsVal_int(obj3, &val4);
15177 if (!SWIG_IsOK(ecode4)) {
15178 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15179 }
15180 arg4 = static_cast< int >(val4);
15181 {
15182 PyThreadState* __tstate = wxPyBeginAllowThreads();
15183 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15184 wxPyEndAllowThreads(__tstate);
15185 if (PyErr_Occurred()) SWIG_fail;
15186 }
15187 resultobj = SWIG_Py_Void();
15188 return resultobj;
15189 fail:
15190 return NULL;
15191 }
15192
15193
15194 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15195 PyObject *resultobj = 0;
15196 wxImage *arg1 = (wxImage *) 0 ;
15197 PyObject *result = 0 ;
15198 void *argp1 = 0 ;
15199 int res1 = 0 ;
15200 PyObject *swig_obj[1] ;
15201
15202 if (!args) SWIG_fail;
15203 swig_obj[0] = args;
15204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15205 if (!SWIG_IsOK(res1)) {
15206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15207 }
15208 arg1 = reinterpret_cast< wxImage * >(argp1);
15209 {
15210 PyThreadState* __tstate = wxPyBeginAllowThreads();
15211 result = (PyObject *)wxImage_GetData(arg1);
15212 wxPyEndAllowThreads(__tstate);
15213 if (PyErr_Occurred()) SWIG_fail;
15214 }
15215 resultobj = result;
15216 return resultobj;
15217 fail:
15218 return NULL;
15219 }
15220
15221
15222 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15223 PyObject *resultobj = 0;
15224 wxImage *arg1 = (wxImage *) 0 ;
15225 buffer arg2 ;
15226 int arg3 ;
15227 void *argp1 = 0 ;
15228 int res1 = 0 ;
15229 PyObject * obj0 = 0 ;
15230 PyObject * obj1 = 0 ;
15231 char * kwnames[] = {
15232 (char *) "self",(char *) "data", NULL
15233 };
15234
15235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15237 if (!SWIG_IsOK(res1)) {
15238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15239 }
15240 arg1 = reinterpret_cast< wxImage * >(argp1);
15241 {
15242 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15243 }
15244 {
15245 PyThreadState* __tstate = wxPyBeginAllowThreads();
15246 wxImage_SetData(arg1,arg2,arg3);
15247 wxPyEndAllowThreads(__tstate);
15248 if (PyErr_Occurred()) SWIG_fail;
15249 }
15250 resultobj = SWIG_Py_Void();
15251 return resultobj;
15252 fail:
15253 return NULL;
15254 }
15255
15256
15257 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15258 PyObject *resultobj = 0;
15259 wxImage *arg1 = (wxImage *) 0 ;
15260 PyObject *result = 0 ;
15261 void *argp1 = 0 ;
15262 int res1 = 0 ;
15263 PyObject *swig_obj[1] ;
15264
15265 if (!args) SWIG_fail;
15266 swig_obj[0] = args;
15267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15268 if (!SWIG_IsOK(res1)) {
15269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15270 }
15271 arg1 = reinterpret_cast< wxImage * >(argp1);
15272 {
15273 PyThreadState* __tstate = wxPyBeginAllowThreads();
15274 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15275 wxPyEndAllowThreads(__tstate);
15276 if (PyErr_Occurred()) SWIG_fail;
15277 }
15278 resultobj = result;
15279 return resultobj;
15280 fail:
15281 return NULL;
15282 }
15283
15284
15285 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15286 PyObject *resultobj = 0;
15287 wxImage *arg1 = (wxImage *) 0 ;
15288 buffer arg2 ;
15289 int arg3 ;
15290 void *argp1 = 0 ;
15291 int res1 = 0 ;
15292 PyObject * obj0 = 0 ;
15293 PyObject * obj1 = 0 ;
15294 char * kwnames[] = {
15295 (char *) "self",(char *) "data", NULL
15296 };
15297
15298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15300 if (!SWIG_IsOK(res1)) {
15301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15302 }
15303 arg1 = reinterpret_cast< wxImage * >(argp1);
15304 {
15305 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15306 }
15307 {
15308 PyThreadState* __tstate = wxPyBeginAllowThreads();
15309 wxImage_SetDataBuffer(arg1,arg2,arg3);
15310 wxPyEndAllowThreads(__tstate);
15311 if (PyErr_Occurred()) SWIG_fail;
15312 }
15313 resultobj = SWIG_Py_Void();
15314 return resultobj;
15315 fail:
15316 return NULL;
15317 }
15318
15319
15320 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15321 PyObject *resultobj = 0;
15322 wxImage *arg1 = (wxImage *) 0 ;
15323 PyObject *result = 0 ;
15324 void *argp1 = 0 ;
15325 int res1 = 0 ;
15326 PyObject *swig_obj[1] ;
15327
15328 if (!args) SWIG_fail;
15329 swig_obj[0] = args;
15330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15331 if (!SWIG_IsOK(res1)) {
15332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15333 }
15334 arg1 = reinterpret_cast< wxImage * >(argp1);
15335 {
15336 PyThreadState* __tstate = wxPyBeginAllowThreads();
15337 result = (PyObject *)wxImage_GetAlphaData(arg1);
15338 wxPyEndAllowThreads(__tstate);
15339 if (PyErr_Occurred()) SWIG_fail;
15340 }
15341 resultobj = result;
15342 return resultobj;
15343 fail:
15344 return NULL;
15345 }
15346
15347
15348 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15349 PyObject *resultobj = 0;
15350 wxImage *arg1 = (wxImage *) 0 ;
15351 buffer arg2 ;
15352 int arg3 ;
15353 void *argp1 = 0 ;
15354 int res1 = 0 ;
15355 PyObject * obj0 = 0 ;
15356 PyObject * obj1 = 0 ;
15357 char * kwnames[] = {
15358 (char *) "self",(char *) "alpha", NULL
15359 };
15360
15361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15363 if (!SWIG_IsOK(res1)) {
15364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15365 }
15366 arg1 = reinterpret_cast< wxImage * >(argp1);
15367 {
15368 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15369 }
15370 {
15371 PyThreadState* __tstate = wxPyBeginAllowThreads();
15372 wxImage_SetAlphaData(arg1,arg2,arg3);
15373 wxPyEndAllowThreads(__tstate);
15374 if (PyErr_Occurred()) SWIG_fail;
15375 }
15376 resultobj = SWIG_Py_Void();
15377 return resultobj;
15378 fail:
15379 return NULL;
15380 }
15381
15382
15383 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15384 PyObject *resultobj = 0;
15385 wxImage *arg1 = (wxImage *) 0 ;
15386 PyObject *result = 0 ;
15387 void *argp1 = 0 ;
15388 int res1 = 0 ;
15389 PyObject *swig_obj[1] ;
15390
15391 if (!args) SWIG_fail;
15392 swig_obj[0] = args;
15393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15394 if (!SWIG_IsOK(res1)) {
15395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15396 }
15397 arg1 = reinterpret_cast< wxImage * >(argp1);
15398 {
15399 PyThreadState* __tstate = wxPyBeginAllowThreads();
15400 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15401 wxPyEndAllowThreads(__tstate);
15402 if (PyErr_Occurred()) SWIG_fail;
15403 }
15404 resultobj = result;
15405 return resultobj;
15406 fail:
15407 return NULL;
15408 }
15409
15410
15411 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15412 PyObject *resultobj = 0;
15413 wxImage *arg1 = (wxImage *) 0 ;
15414 buffer arg2 ;
15415 int arg3 ;
15416 void *argp1 = 0 ;
15417 int res1 = 0 ;
15418 PyObject * obj0 = 0 ;
15419 PyObject * obj1 = 0 ;
15420 char * kwnames[] = {
15421 (char *) "self",(char *) "alpha", NULL
15422 };
15423
15424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15426 if (!SWIG_IsOK(res1)) {
15427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15428 }
15429 arg1 = reinterpret_cast< wxImage * >(argp1);
15430 {
15431 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15432 }
15433 {
15434 PyThreadState* __tstate = wxPyBeginAllowThreads();
15435 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15436 wxPyEndAllowThreads(__tstate);
15437 if (PyErr_Occurred()) SWIG_fail;
15438 }
15439 resultobj = SWIG_Py_Void();
15440 return resultobj;
15441 fail:
15442 return NULL;
15443 }
15444
15445
15446 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15447 PyObject *resultobj = 0;
15448 wxImage *arg1 = (wxImage *) 0 ;
15449 byte arg2 ;
15450 byte arg3 ;
15451 byte arg4 ;
15452 void *argp1 = 0 ;
15453 int res1 = 0 ;
15454 unsigned char val2 ;
15455 int ecode2 = 0 ;
15456 unsigned char val3 ;
15457 int ecode3 = 0 ;
15458 unsigned char val4 ;
15459 int ecode4 = 0 ;
15460 PyObject * obj0 = 0 ;
15461 PyObject * obj1 = 0 ;
15462 PyObject * obj2 = 0 ;
15463 PyObject * obj3 = 0 ;
15464 char * kwnames[] = {
15465 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15466 };
15467
15468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15470 if (!SWIG_IsOK(res1)) {
15471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15472 }
15473 arg1 = reinterpret_cast< wxImage * >(argp1);
15474 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15475 if (!SWIG_IsOK(ecode2)) {
15476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15477 }
15478 arg2 = static_cast< byte >(val2);
15479 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15480 if (!SWIG_IsOK(ecode3)) {
15481 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15482 }
15483 arg3 = static_cast< byte >(val3);
15484 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15485 if (!SWIG_IsOK(ecode4)) {
15486 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15487 }
15488 arg4 = static_cast< byte >(val4);
15489 {
15490 PyThreadState* __tstate = wxPyBeginAllowThreads();
15491 (arg1)->SetMaskColour(arg2,arg3,arg4);
15492 wxPyEndAllowThreads(__tstate);
15493 if (PyErr_Occurred()) SWIG_fail;
15494 }
15495 resultobj = SWIG_Py_Void();
15496 return resultobj;
15497 fail:
15498 return NULL;
15499 }
15500
15501
15502 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15503 PyObject *resultobj = 0;
15504 wxImage *arg1 = (wxImage *) 0 ;
15505 byte *arg2 = (byte *) 0 ;
15506 byte *arg3 = (byte *) 0 ;
15507 byte *arg4 = (byte *) 0 ;
15508 void *argp1 = 0 ;
15509 int res1 = 0 ;
15510 byte temp2 ;
15511 int res2 = SWIG_TMPOBJ ;
15512 byte temp3 ;
15513 int res3 = SWIG_TMPOBJ ;
15514 byte temp4 ;
15515 int res4 = SWIG_TMPOBJ ;
15516 PyObject *swig_obj[1] ;
15517
15518 arg2 = &temp2;
15519 arg3 = &temp3;
15520 arg4 = &temp4;
15521 if (!args) SWIG_fail;
15522 swig_obj[0] = args;
15523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15524 if (!SWIG_IsOK(res1)) {
15525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15526 }
15527 arg1 = reinterpret_cast< wxImage * >(argp1);
15528 {
15529 PyThreadState* __tstate = wxPyBeginAllowThreads();
15530 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15531 wxPyEndAllowThreads(__tstate);
15532 if (PyErr_Occurred()) SWIG_fail;
15533 }
15534 resultobj = SWIG_Py_Void();
15535 if (SWIG_IsTmpObj(res2)) {
15536 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15537 } else {
15538 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15539 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15540 }
15541 if (SWIG_IsTmpObj(res3)) {
15542 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15543 } else {
15544 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15545 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15546 }
15547 if (SWIG_IsTmpObj(res4)) {
15548 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15549 } else {
15550 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15551 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15552 }
15553 return resultobj;
15554 fail:
15555 return NULL;
15556 }
15557
15558
15559 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15560 PyObject *resultobj = 0;
15561 wxImage *arg1 = (wxImage *) 0 ;
15562 byte result;
15563 void *argp1 = 0 ;
15564 int res1 = 0 ;
15565 PyObject *swig_obj[1] ;
15566
15567 if (!args) SWIG_fail;
15568 swig_obj[0] = args;
15569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15570 if (!SWIG_IsOK(res1)) {
15571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15572 }
15573 arg1 = reinterpret_cast< wxImage * >(argp1);
15574 {
15575 PyThreadState* __tstate = wxPyBeginAllowThreads();
15576 result = (byte)(arg1)->GetMaskRed();
15577 wxPyEndAllowThreads(__tstate);
15578 if (PyErr_Occurred()) SWIG_fail;
15579 }
15580 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15581 return resultobj;
15582 fail:
15583 return NULL;
15584 }
15585
15586
15587 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15588 PyObject *resultobj = 0;
15589 wxImage *arg1 = (wxImage *) 0 ;
15590 byte result;
15591 void *argp1 = 0 ;
15592 int res1 = 0 ;
15593 PyObject *swig_obj[1] ;
15594
15595 if (!args) SWIG_fail;
15596 swig_obj[0] = args;
15597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15598 if (!SWIG_IsOK(res1)) {
15599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15600 }
15601 arg1 = reinterpret_cast< wxImage * >(argp1);
15602 {
15603 PyThreadState* __tstate = wxPyBeginAllowThreads();
15604 result = (byte)(arg1)->GetMaskGreen();
15605 wxPyEndAllowThreads(__tstate);
15606 if (PyErr_Occurred()) SWIG_fail;
15607 }
15608 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15609 return resultobj;
15610 fail:
15611 return NULL;
15612 }
15613
15614
15615 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15616 PyObject *resultobj = 0;
15617 wxImage *arg1 = (wxImage *) 0 ;
15618 byte result;
15619 void *argp1 = 0 ;
15620 int res1 = 0 ;
15621 PyObject *swig_obj[1] ;
15622
15623 if (!args) SWIG_fail;
15624 swig_obj[0] = args;
15625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15626 if (!SWIG_IsOK(res1)) {
15627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15628 }
15629 arg1 = reinterpret_cast< wxImage * >(argp1);
15630 {
15631 PyThreadState* __tstate = wxPyBeginAllowThreads();
15632 result = (byte)(arg1)->GetMaskBlue();
15633 wxPyEndAllowThreads(__tstate);
15634 if (PyErr_Occurred()) SWIG_fail;
15635 }
15636 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15637 return resultobj;
15638 fail:
15639 return NULL;
15640 }
15641
15642
15643 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15644 PyObject *resultobj = 0;
15645 wxImage *arg1 = (wxImage *) 0 ;
15646 bool arg2 = (bool) true ;
15647 void *argp1 = 0 ;
15648 int res1 = 0 ;
15649 bool val2 ;
15650 int ecode2 = 0 ;
15651 PyObject * obj0 = 0 ;
15652 PyObject * obj1 = 0 ;
15653 char * kwnames[] = {
15654 (char *) "self",(char *) "mask", NULL
15655 };
15656
15657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15659 if (!SWIG_IsOK(res1)) {
15660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15661 }
15662 arg1 = reinterpret_cast< wxImage * >(argp1);
15663 if (obj1) {
15664 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15665 if (!SWIG_IsOK(ecode2)) {
15666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15667 }
15668 arg2 = static_cast< bool >(val2);
15669 }
15670 {
15671 PyThreadState* __tstate = wxPyBeginAllowThreads();
15672 (arg1)->SetMask(arg2);
15673 wxPyEndAllowThreads(__tstate);
15674 if (PyErr_Occurred()) SWIG_fail;
15675 }
15676 resultobj = SWIG_Py_Void();
15677 return resultobj;
15678 fail:
15679 return NULL;
15680 }
15681
15682
15683 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15684 PyObject *resultobj = 0;
15685 wxImage *arg1 = (wxImage *) 0 ;
15686 bool result;
15687 void *argp1 = 0 ;
15688 int res1 = 0 ;
15689 PyObject *swig_obj[1] ;
15690
15691 if (!args) SWIG_fail;
15692 swig_obj[0] = args;
15693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15694 if (!SWIG_IsOK(res1)) {
15695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15696 }
15697 arg1 = reinterpret_cast< wxImage * >(argp1);
15698 {
15699 PyThreadState* __tstate = wxPyBeginAllowThreads();
15700 result = (bool)(arg1)->HasMask();
15701 wxPyEndAllowThreads(__tstate);
15702 if (PyErr_Occurred()) SWIG_fail;
15703 }
15704 {
15705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15706 }
15707 return resultobj;
15708 fail:
15709 return NULL;
15710 }
15711
15712
15713 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15714 PyObject *resultobj = 0;
15715 wxImage *arg1 = (wxImage *) 0 ;
15716 double arg2 ;
15717 wxPoint *arg3 = 0 ;
15718 bool arg4 = (bool) true ;
15719 wxPoint *arg5 = (wxPoint *) NULL ;
15720 SwigValueWrapper<wxImage > result;
15721 void *argp1 = 0 ;
15722 int res1 = 0 ;
15723 double val2 ;
15724 int ecode2 = 0 ;
15725 wxPoint temp3 ;
15726 bool val4 ;
15727 int ecode4 = 0 ;
15728 void *argp5 = 0 ;
15729 int res5 = 0 ;
15730 PyObject * obj0 = 0 ;
15731 PyObject * obj1 = 0 ;
15732 PyObject * obj2 = 0 ;
15733 PyObject * obj3 = 0 ;
15734 PyObject * obj4 = 0 ;
15735 char * kwnames[] = {
15736 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15737 };
15738
15739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15741 if (!SWIG_IsOK(res1)) {
15742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15743 }
15744 arg1 = reinterpret_cast< wxImage * >(argp1);
15745 ecode2 = SWIG_AsVal_double(obj1, &val2);
15746 if (!SWIG_IsOK(ecode2)) {
15747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15748 }
15749 arg2 = static_cast< double >(val2);
15750 {
15751 arg3 = &temp3;
15752 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15753 }
15754 if (obj3) {
15755 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15756 if (!SWIG_IsOK(ecode4)) {
15757 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15758 }
15759 arg4 = static_cast< bool >(val4);
15760 }
15761 if (obj4) {
15762 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15763 if (!SWIG_IsOK(res5)) {
15764 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15765 }
15766 arg5 = reinterpret_cast< wxPoint * >(argp5);
15767 }
15768 {
15769 PyThreadState* __tstate = wxPyBeginAllowThreads();
15770 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15771 wxPyEndAllowThreads(__tstate);
15772 if (PyErr_Occurred()) SWIG_fail;
15773 }
15774 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15775 return resultobj;
15776 fail:
15777 return NULL;
15778 }
15779
15780
15781 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15782 PyObject *resultobj = 0;
15783 wxImage *arg1 = (wxImage *) 0 ;
15784 bool arg2 = (bool) true ;
15785 SwigValueWrapper<wxImage > result;
15786 void *argp1 = 0 ;
15787 int res1 = 0 ;
15788 bool val2 ;
15789 int ecode2 = 0 ;
15790 PyObject * obj0 = 0 ;
15791 PyObject * obj1 = 0 ;
15792 char * kwnames[] = {
15793 (char *) "self",(char *) "clockwise", NULL
15794 };
15795
15796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15798 if (!SWIG_IsOK(res1)) {
15799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15800 }
15801 arg1 = reinterpret_cast< wxImage * >(argp1);
15802 if (obj1) {
15803 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15804 if (!SWIG_IsOK(ecode2)) {
15805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15806 }
15807 arg2 = static_cast< bool >(val2);
15808 }
15809 {
15810 PyThreadState* __tstate = wxPyBeginAllowThreads();
15811 result = (arg1)->Rotate90(arg2);
15812 wxPyEndAllowThreads(__tstate);
15813 if (PyErr_Occurred()) SWIG_fail;
15814 }
15815 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15816 return resultobj;
15817 fail:
15818 return NULL;
15819 }
15820
15821
15822 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15823 PyObject *resultobj = 0;
15824 wxImage *arg1 = (wxImage *) 0 ;
15825 bool arg2 = (bool) true ;
15826 SwigValueWrapper<wxImage > result;
15827 void *argp1 = 0 ;
15828 int res1 = 0 ;
15829 bool val2 ;
15830 int ecode2 = 0 ;
15831 PyObject * obj0 = 0 ;
15832 PyObject * obj1 = 0 ;
15833 char * kwnames[] = {
15834 (char *) "self",(char *) "horizontally", NULL
15835 };
15836
15837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15839 if (!SWIG_IsOK(res1)) {
15840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15841 }
15842 arg1 = reinterpret_cast< wxImage * >(argp1);
15843 if (obj1) {
15844 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15845 if (!SWIG_IsOK(ecode2)) {
15846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15847 }
15848 arg2 = static_cast< bool >(val2);
15849 }
15850 {
15851 PyThreadState* __tstate = wxPyBeginAllowThreads();
15852 result = (arg1)->Mirror(arg2);
15853 wxPyEndAllowThreads(__tstate);
15854 if (PyErr_Occurred()) SWIG_fail;
15855 }
15856 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15857 return resultobj;
15858 fail:
15859 return NULL;
15860 }
15861
15862
15863 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15864 PyObject *resultobj = 0;
15865 wxImage *arg1 = (wxImage *) 0 ;
15866 byte arg2 ;
15867 byte arg3 ;
15868 byte arg4 ;
15869 byte arg5 ;
15870 byte arg6 ;
15871 byte arg7 ;
15872 void *argp1 = 0 ;
15873 int res1 = 0 ;
15874 unsigned char val2 ;
15875 int ecode2 = 0 ;
15876 unsigned char val3 ;
15877 int ecode3 = 0 ;
15878 unsigned char val4 ;
15879 int ecode4 = 0 ;
15880 unsigned char val5 ;
15881 int ecode5 = 0 ;
15882 unsigned char val6 ;
15883 int ecode6 = 0 ;
15884 unsigned char val7 ;
15885 int ecode7 = 0 ;
15886 PyObject * obj0 = 0 ;
15887 PyObject * obj1 = 0 ;
15888 PyObject * obj2 = 0 ;
15889 PyObject * obj3 = 0 ;
15890 PyObject * obj4 = 0 ;
15891 PyObject * obj5 = 0 ;
15892 PyObject * obj6 = 0 ;
15893 char * kwnames[] = {
15894 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15895 };
15896
15897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15899 if (!SWIG_IsOK(res1)) {
15900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15901 }
15902 arg1 = reinterpret_cast< wxImage * >(argp1);
15903 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15904 if (!SWIG_IsOK(ecode2)) {
15905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
15906 }
15907 arg2 = static_cast< byte >(val2);
15908 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15909 if (!SWIG_IsOK(ecode3)) {
15910 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
15911 }
15912 arg3 = static_cast< byte >(val3);
15913 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15914 if (!SWIG_IsOK(ecode4)) {
15915 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
15916 }
15917 arg4 = static_cast< byte >(val4);
15918 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15919 if (!SWIG_IsOK(ecode5)) {
15920 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
15921 }
15922 arg5 = static_cast< byte >(val5);
15923 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
15924 if (!SWIG_IsOK(ecode6)) {
15925 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
15926 }
15927 arg6 = static_cast< byte >(val6);
15928 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
15929 if (!SWIG_IsOK(ecode7)) {
15930 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
15931 }
15932 arg7 = static_cast< byte >(val7);
15933 {
15934 PyThreadState* __tstate = wxPyBeginAllowThreads();
15935 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
15936 wxPyEndAllowThreads(__tstate);
15937 if (PyErr_Occurred()) SWIG_fail;
15938 }
15939 resultobj = SWIG_Py_Void();
15940 return resultobj;
15941 fail:
15942 return NULL;
15943 }
15944
15945
15946 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15947 PyObject *resultobj = 0;
15948 wxImage *arg1 = (wxImage *) 0 ;
15949 double arg2 = (double) 0.299 ;
15950 double arg3 = (double) 0.587 ;
15951 double arg4 = (double) 0.114 ;
15952 SwigValueWrapper<wxImage > result;
15953 void *argp1 = 0 ;
15954 int res1 = 0 ;
15955 double val2 ;
15956 int ecode2 = 0 ;
15957 double val3 ;
15958 int ecode3 = 0 ;
15959 double val4 ;
15960 int ecode4 = 0 ;
15961 PyObject * obj0 = 0 ;
15962 PyObject * obj1 = 0 ;
15963 PyObject * obj2 = 0 ;
15964 PyObject * obj3 = 0 ;
15965 char * kwnames[] = {
15966 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
15967 };
15968
15969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15971 if (!SWIG_IsOK(res1)) {
15972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
15973 }
15974 arg1 = reinterpret_cast< wxImage * >(argp1);
15975 if (obj1) {
15976 ecode2 = SWIG_AsVal_double(obj1, &val2);
15977 if (!SWIG_IsOK(ecode2)) {
15978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
15979 }
15980 arg2 = static_cast< double >(val2);
15981 }
15982 if (obj2) {
15983 ecode3 = SWIG_AsVal_double(obj2, &val3);
15984 if (!SWIG_IsOK(ecode3)) {
15985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
15986 }
15987 arg3 = static_cast< double >(val3);
15988 }
15989 if (obj3) {
15990 ecode4 = SWIG_AsVal_double(obj3, &val4);
15991 if (!SWIG_IsOK(ecode4)) {
15992 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
15993 }
15994 arg4 = static_cast< double >(val4);
15995 }
15996 {
15997 PyThreadState* __tstate = wxPyBeginAllowThreads();
15998 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
15999 wxPyEndAllowThreads(__tstate);
16000 if (PyErr_Occurred()) SWIG_fail;
16001 }
16002 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16003 return resultobj;
16004 fail:
16005 return NULL;
16006 }
16007
16008
16009 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16010 PyObject *resultobj = 0;
16011 wxImage *arg1 = (wxImage *) 0 ;
16012 byte arg2 ;
16013 byte arg3 ;
16014 byte arg4 ;
16015 SwigValueWrapper<wxImage > result;
16016 void *argp1 = 0 ;
16017 int res1 = 0 ;
16018 unsigned char val2 ;
16019 int ecode2 = 0 ;
16020 unsigned char val3 ;
16021 int ecode3 = 0 ;
16022 unsigned char val4 ;
16023 int ecode4 = 0 ;
16024 PyObject * obj0 = 0 ;
16025 PyObject * obj1 = 0 ;
16026 PyObject * obj2 = 0 ;
16027 PyObject * obj3 = 0 ;
16028 char * kwnames[] = {
16029 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16030 };
16031
16032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16034 if (!SWIG_IsOK(res1)) {
16035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16036 }
16037 arg1 = reinterpret_cast< wxImage * >(argp1);
16038 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16039 if (!SWIG_IsOK(ecode2)) {
16040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16041 }
16042 arg2 = static_cast< byte >(val2);
16043 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16044 if (!SWIG_IsOK(ecode3)) {
16045 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16046 }
16047 arg3 = static_cast< byte >(val3);
16048 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16049 if (!SWIG_IsOK(ecode4)) {
16050 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16051 }
16052 arg4 = static_cast< byte >(val4);
16053 {
16054 PyThreadState* __tstate = wxPyBeginAllowThreads();
16055 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16056 wxPyEndAllowThreads(__tstate);
16057 if (PyErr_Occurred()) SWIG_fail;
16058 }
16059 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16060 return resultobj;
16061 fail:
16062 return NULL;
16063 }
16064
16065
16066 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16067 PyObject *resultobj = 0;
16068 wxImage *arg1 = (wxImage *) 0 ;
16069 wxString *arg2 = 0 ;
16070 wxString *arg3 = 0 ;
16071 void *argp1 = 0 ;
16072 int res1 = 0 ;
16073 bool temp2 = false ;
16074 bool temp3 = false ;
16075 PyObject * obj0 = 0 ;
16076 PyObject * obj1 = 0 ;
16077 PyObject * obj2 = 0 ;
16078 char * kwnames[] = {
16079 (char *) "self",(char *) "name",(char *) "value", NULL
16080 };
16081
16082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16084 if (!SWIG_IsOK(res1)) {
16085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16086 }
16087 arg1 = reinterpret_cast< wxImage * >(argp1);
16088 {
16089 arg2 = wxString_in_helper(obj1);
16090 if (arg2 == NULL) SWIG_fail;
16091 temp2 = true;
16092 }
16093 {
16094 arg3 = wxString_in_helper(obj2);
16095 if (arg3 == NULL) SWIG_fail;
16096 temp3 = true;
16097 }
16098 {
16099 PyThreadState* __tstate = wxPyBeginAllowThreads();
16100 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16101 wxPyEndAllowThreads(__tstate);
16102 if (PyErr_Occurred()) SWIG_fail;
16103 }
16104 resultobj = SWIG_Py_Void();
16105 {
16106 if (temp2)
16107 delete arg2;
16108 }
16109 {
16110 if (temp3)
16111 delete arg3;
16112 }
16113 return resultobj;
16114 fail:
16115 {
16116 if (temp2)
16117 delete arg2;
16118 }
16119 {
16120 if (temp3)
16121 delete arg3;
16122 }
16123 return NULL;
16124 }
16125
16126
16127 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16128 PyObject *resultobj = 0;
16129 wxImage *arg1 = (wxImage *) 0 ;
16130 wxString *arg2 = 0 ;
16131 int arg3 ;
16132 void *argp1 = 0 ;
16133 int res1 = 0 ;
16134 bool temp2 = false ;
16135 int val3 ;
16136 int ecode3 = 0 ;
16137 PyObject * obj0 = 0 ;
16138 PyObject * obj1 = 0 ;
16139 PyObject * obj2 = 0 ;
16140 char * kwnames[] = {
16141 (char *) "self",(char *) "name",(char *) "value", NULL
16142 };
16143
16144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16146 if (!SWIG_IsOK(res1)) {
16147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16148 }
16149 arg1 = reinterpret_cast< wxImage * >(argp1);
16150 {
16151 arg2 = wxString_in_helper(obj1);
16152 if (arg2 == NULL) SWIG_fail;
16153 temp2 = true;
16154 }
16155 ecode3 = SWIG_AsVal_int(obj2, &val3);
16156 if (!SWIG_IsOK(ecode3)) {
16157 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16158 }
16159 arg3 = static_cast< int >(val3);
16160 {
16161 PyThreadState* __tstate = wxPyBeginAllowThreads();
16162 (arg1)->SetOption((wxString const &)*arg2,arg3);
16163 wxPyEndAllowThreads(__tstate);
16164 if (PyErr_Occurred()) SWIG_fail;
16165 }
16166 resultobj = SWIG_Py_Void();
16167 {
16168 if (temp2)
16169 delete arg2;
16170 }
16171 return resultobj;
16172 fail:
16173 {
16174 if (temp2)
16175 delete arg2;
16176 }
16177 return NULL;
16178 }
16179
16180
16181 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16182 PyObject *resultobj = 0;
16183 wxImage *arg1 = (wxImage *) 0 ;
16184 wxString *arg2 = 0 ;
16185 wxString result;
16186 void *argp1 = 0 ;
16187 int res1 = 0 ;
16188 bool temp2 = false ;
16189 PyObject * obj0 = 0 ;
16190 PyObject * obj1 = 0 ;
16191 char * kwnames[] = {
16192 (char *) "self",(char *) "name", NULL
16193 };
16194
16195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16197 if (!SWIG_IsOK(res1)) {
16198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16199 }
16200 arg1 = reinterpret_cast< wxImage * >(argp1);
16201 {
16202 arg2 = wxString_in_helper(obj1);
16203 if (arg2 == NULL) SWIG_fail;
16204 temp2 = true;
16205 }
16206 {
16207 PyThreadState* __tstate = wxPyBeginAllowThreads();
16208 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16209 wxPyEndAllowThreads(__tstate);
16210 if (PyErr_Occurred()) SWIG_fail;
16211 }
16212 {
16213 #if wxUSE_UNICODE
16214 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16215 #else
16216 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16217 #endif
16218 }
16219 {
16220 if (temp2)
16221 delete arg2;
16222 }
16223 return resultobj;
16224 fail:
16225 {
16226 if (temp2)
16227 delete arg2;
16228 }
16229 return NULL;
16230 }
16231
16232
16233 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16234 PyObject *resultobj = 0;
16235 wxImage *arg1 = (wxImage *) 0 ;
16236 wxString *arg2 = 0 ;
16237 int result;
16238 void *argp1 = 0 ;
16239 int res1 = 0 ;
16240 bool temp2 = false ;
16241 PyObject * obj0 = 0 ;
16242 PyObject * obj1 = 0 ;
16243 char * kwnames[] = {
16244 (char *) "self",(char *) "name", NULL
16245 };
16246
16247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16249 if (!SWIG_IsOK(res1)) {
16250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16251 }
16252 arg1 = reinterpret_cast< wxImage * >(argp1);
16253 {
16254 arg2 = wxString_in_helper(obj1);
16255 if (arg2 == NULL) SWIG_fail;
16256 temp2 = true;
16257 }
16258 {
16259 PyThreadState* __tstate = wxPyBeginAllowThreads();
16260 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16261 wxPyEndAllowThreads(__tstate);
16262 if (PyErr_Occurred()) SWIG_fail;
16263 }
16264 resultobj = SWIG_From_int(static_cast< int >(result));
16265 {
16266 if (temp2)
16267 delete arg2;
16268 }
16269 return resultobj;
16270 fail:
16271 {
16272 if (temp2)
16273 delete arg2;
16274 }
16275 return NULL;
16276 }
16277
16278
16279 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16280 PyObject *resultobj = 0;
16281 wxImage *arg1 = (wxImage *) 0 ;
16282 wxString *arg2 = 0 ;
16283 bool result;
16284 void *argp1 = 0 ;
16285 int res1 = 0 ;
16286 bool temp2 = false ;
16287 PyObject * obj0 = 0 ;
16288 PyObject * obj1 = 0 ;
16289 char * kwnames[] = {
16290 (char *) "self",(char *) "name", NULL
16291 };
16292
16293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16295 if (!SWIG_IsOK(res1)) {
16296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16297 }
16298 arg1 = reinterpret_cast< wxImage * >(argp1);
16299 {
16300 arg2 = wxString_in_helper(obj1);
16301 if (arg2 == NULL) SWIG_fail;
16302 temp2 = true;
16303 }
16304 {
16305 PyThreadState* __tstate = wxPyBeginAllowThreads();
16306 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16307 wxPyEndAllowThreads(__tstate);
16308 if (PyErr_Occurred()) SWIG_fail;
16309 }
16310 {
16311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16312 }
16313 {
16314 if (temp2)
16315 delete arg2;
16316 }
16317 return resultobj;
16318 fail:
16319 {
16320 if (temp2)
16321 delete arg2;
16322 }
16323 return NULL;
16324 }
16325
16326
16327 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16328 PyObject *resultobj = 0;
16329 wxImage *arg1 = (wxImage *) 0 ;
16330 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16331 unsigned long result;
16332 void *argp1 = 0 ;
16333 int res1 = 0 ;
16334 unsigned long val2 ;
16335 int ecode2 = 0 ;
16336 PyObject * obj0 = 0 ;
16337 PyObject * obj1 = 0 ;
16338 char * kwnames[] = {
16339 (char *) "self",(char *) "stopafter", NULL
16340 };
16341
16342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16344 if (!SWIG_IsOK(res1)) {
16345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16346 }
16347 arg1 = reinterpret_cast< wxImage * >(argp1);
16348 if (obj1) {
16349 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16350 if (!SWIG_IsOK(ecode2)) {
16351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16352 }
16353 arg2 = static_cast< unsigned long >(val2);
16354 }
16355 {
16356 PyThreadState* __tstate = wxPyBeginAllowThreads();
16357 result = (unsigned long)(arg1)->CountColours(arg2);
16358 wxPyEndAllowThreads(__tstate);
16359 if (PyErr_Occurred()) SWIG_fail;
16360 }
16361 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16362 return resultobj;
16363 fail:
16364 return NULL;
16365 }
16366
16367
16368 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16369 PyObject *resultobj = 0;
16370 wxImage *arg1 = (wxImage *) 0 ;
16371 wxImageHistogram *arg2 = 0 ;
16372 unsigned long result;
16373 void *argp1 = 0 ;
16374 int res1 = 0 ;
16375 void *argp2 = 0 ;
16376 int res2 = 0 ;
16377 PyObject * obj0 = 0 ;
16378 PyObject * obj1 = 0 ;
16379 char * kwnames[] = {
16380 (char *) "self",(char *) "h", NULL
16381 };
16382
16383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16385 if (!SWIG_IsOK(res1)) {
16386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16387 }
16388 arg1 = reinterpret_cast< wxImage * >(argp1);
16389 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16390 if (!SWIG_IsOK(res2)) {
16391 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16392 }
16393 if (!argp2) {
16394 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16395 }
16396 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16397 {
16398 PyThreadState* __tstate = wxPyBeginAllowThreads();
16399 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16400 wxPyEndAllowThreads(__tstate);
16401 if (PyErr_Occurred()) SWIG_fail;
16402 }
16403 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16404 return resultobj;
16405 fail:
16406 return NULL;
16407 }
16408
16409
16410 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16411 PyObject *resultobj = 0;
16412 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16413 void *argp1 = 0 ;
16414 int res1 = 0 ;
16415 PyObject * obj0 = 0 ;
16416 char * kwnames[] = {
16417 (char *) "handler", NULL
16418 };
16419
16420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16422 if (!SWIG_IsOK(res1)) {
16423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16424 }
16425 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16426 {
16427 PyThreadState* __tstate = wxPyBeginAllowThreads();
16428 wxImage::AddHandler(arg1);
16429 wxPyEndAllowThreads(__tstate);
16430 if (PyErr_Occurred()) SWIG_fail;
16431 }
16432 resultobj = SWIG_Py_Void();
16433 return resultobj;
16434 fail:
16435 return NULL;
16436 }
16437
16438
16439 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16440 PyObject *resultobj = 0;
16441 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16442 void *argp1 = 0 ;
16443 int res1 = 0 ;
16444 PyObject * obj0 = 0 ;
16445 char * kwnames[] = {
16446 (char *) "handler", NULL
16447 };
16448
16449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16451 if (!SWIG_IsOK(res1)) {
16452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16453 }
16454 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16455 {
16456 PyThreadState* __tstate = wxPyBeginAllowThreads();
16457 wxImage::InsertHandler(arg1);
16458 wxPyEndAllowThreads(__tstate);
16459 if (PyErr_Occurred()) SWIG_fail;
16460 }
16461 resultobj = SWIG_Py_Void();
16462 return resultobj;
16463 fail:
16464 return NULL;
16465 }
16466
16467
16468 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16469 PyObject *resultobj = 0;
16470 wxString *arg1 = 0 ;
16471 bool result;
16472 bool temp1 = false ;
16473 PyObject * obj0 = 0 ;
16474 char * kwnames[] = {
16475 (char *) "name", NULL
16476 };
16477
16478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16479 {
16480 arg1 = wxString_in_helper(obj0);
16481 if (arg1 == NULL) SWIG_fail;
16482 temp1 = true;
16483 }
16484 {
16485 PyThreadState* __tstate = wxPyBeginAllowThreads();
16486 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16487 wxPyEndAllowThreads(__tstate);
16488 if (PyErr_Occurred()) SWIG_fail;
16489 }
16490 {
16491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16492 }
16493 {
16494 if (temp1)
16495 delete arg1;
16496 }
16497 return resultobj;
16498 fail:
16499 {
16500 if (temp1)
16501 delete arg1;
16502 }
16503 return NULL;
16504 }
16505
16506
16507 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16508 PyObject *resultobj = 0;
16509 PyObject *result = 0 ;
16510
16511 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16512 {
16513 PyThreadState* __tstate = wxPyBeginAllowThreads();
16514 result = (PyObject *)wxImage_GetHandlers();
16515 wxPyEndAllowThreads(__tstate);
16516 if (PyErr_Occurred()) SWIG_fail;
16517 }
16518 resultobj = result;
16519 return resultobj;
16520 fail:
16521 return NULL;
16522 }
16523
16524
16525 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16526 PyObject *resultobj = 0;
16527 wxString result;
16528
16529 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16530 {
16531 PyThreadState* __tstate = wxPyBeginAllowThreads();
16532 result = wxImage::GetImageExtWildcard();
16533 wxPyEndAllowThreads(__tstate);
16534 if (PyErr_Occurred()) SWIG_fail;
16535 }
16536 {
16537 #if wxUSE_UNICODE
16538 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16539 #else
16540 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16541 #endif
16542 }
16543 return resultobj;
16544 fail:
16545 return NULL;
16546 }
16547
16548
16549 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16550 PyObject *resultobj = 0;
16551 wxImage *arg1 = (wxImage *) 0 ;
16552 int arg2 = (int) -1 ;
16553 wxBitmap result;
16554 void *argp1 = 0 ;
16555 int res1 = 0 ;
16556 int val2 ;
16557 int ecode2 = 0 ;
16558 PyObject * obj0 = 0 ;
16559 PyObject * obj1 = 0 ;
16560 char * kwnames[] = {
16561 (char *) "self",(char *) "depth", NULL
16562 };
16563
16564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16566 if (!SWIG_IsOK(res1)) {
16567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16568 }
16569 arg1 = reinterpret_cast< wxImage * >(argp1);
16570 if (obj1) {
16571 ecode2 = SWIG_AsVal_int(obj1, &val2);
16572 if (!SWIG_IsOK(ecode2)) {
16573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16574 }
16575 arg2 = static_cast< int >(val2);
16576 }
16577 {
16578 if (!wxPyCheckForApp()) SWIG_fail;
16579 PyThreadState* __tstate = wxPyBeginAllowThreads();
16580 result = wxImage_ConvertToBitmap(arg1,arg2);
16581 wxPyEndAllowThreads(__tstate);
16582 if (PyErr_Occurred()) SWIG_fail;
16583 }
16584 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16585 return resultobj;
16586 fail:
16587 return NULL;
16588 }
16589
16590
16591 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16592 PyObject *resultobj = 0;
16593 wxImage *arg1 = (wxImage *) 0 ;
16594 byte arg2 ;
16595 byte arg3 ;
16596 byte arg4 ;
16597 wxBitmap result;
16598 void *argp1 = 0 ;
16599 int res1 = 0 ;
16600 unsigned char val2 ;
16601 int ecode2 = 0 ;
16602 unsigned char val3 ;
16603 int ecode3 = 0 ;
16604 unsigned char val4 ;
16605 int ecode4 = 0 ;
16606 PyObject * obj0 = 0 ;
16607 PyObject * obj1 = 0 ;
16608 PyObject * obj2 = 0 ;
16609 PyObject * obj3 = 0 ;
16610 char * kwnames[] = {
16611 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16612 };
16613
16614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16616 if (!SWIG_IsOK(res1)) {
16617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16618 }
16619 arg1 = reinterpret_cast< wxImage * >(argp1);
16620 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16621 if (!SWIG_IsOK(ecode2)) {
16622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16623 }
16624 arg2 = static_cast< byte >(val2);
16625 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16626 if (!SWIG_IsOK(ecode3)) {
16627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16628 }
16629 arg3 = static_cast< byte >(val3);
16630 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16631 if (!SWIG_IsOK(ecode4)) {
16632 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16633 }
16634 arg4 = static_cast< byte >(val4);
16635 {
16636 if (!wxPyCheckForApp()) SWIG_fail;
16637 PyThreadState* __tstate = wxPyBeginAllowThreads();
16638 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16639 wxPyEndAllowThreads(__tstate);
16640 if (PyErr_Occurred()) SWIG_fail;
16641 }
16642 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16643 return resultobj;
16644 fail:
16645 return NULL;
16646 }
16647
16648
16649 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16650 PyObject *resultobj = 0;
16651 wxImage *arg1 = (wxImage *) 0 ;
16652 double arg2 ;
16653 void *argp1 = 0 ;
16654 int res1 = 0 ;
16655 double val2 ;
16656 int ecode2 = 0 ;
16657 PyObject * obj0 = 0 ;
16658 PyObject * obj1 = 0 ;
16659 char * kwnames[] = {
16660 (char *) "self",(char *) "angle", NULL
16661 };
16662
16663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16665 if (!SWIG_IsOK(res1)) {
16666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16667 }
16668 arg1 = reinterpret_cast< wxImage * >(argp1);
16669 ecode2 = SWIG_AsVal_double(obj1, &val2);
16670 if (!SWIG_IsOK(ecode2)) {
16671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16672 }
16673 arg2 = static_cast< double >(val2);
16674 {
16675 PyThreadState* __tstate = wxPyBeginAllowThreads();
16676 (arg1)->RotateHue(arg2);
16677 wxPyEndAllowThreads(__tstate);
16678 if (PyErr_Occurred()) SWIG_fail;
16679 }
16680 resultobj = SWIG_Py_Void();
16681 return resultobj;
16682 fail:
16683 return NULL;
16684 }
16685
16686
16687 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16688 PyObject *resultobj = 0;
16689 wxImage_RGBValue arg1 ;
16690 wxImage_HSVValue result;
16691 void *argp1 ;
16692 int res1 = 0 ;
16693 PyObject * obj0 = 0 ;
16694 char * kwnames[] = {
16695 (char *) "rgb", NULL
16696 };
16697
16698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16699 {
16700 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16701 if (!SWIG_IsOK(res1)) {
16702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16703 }
16704 if (!argp1) {
16705 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16706 } else {
16707 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16708 arg1 = *temp;
16709 if (SWIG_IsNewObj(res1)) delete temp;
16710 }
16711 }
16712 {
16713 PyThreadState* __tstate = wxPyBeginAllowThreads();
16714 result = wxImage::RGBtoHSV(arg1);
16715 wxPyEndAllowThreads(__tstate);
16716 if (PyErr_Occurred()) SWIG_fail;
16717 }
16718 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16719 return resultobj;
16720 fail:
16721 return NULL;
16722 }
16723
16724
16725 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16726 PyObject *resultobj = 0;
16727 wxImage_HSVValue arg1 ;
16728 wxImage_RGBValue result;
16729 void *argp1 ;
16730 int res1 = 0 ;
16731 PyObject * obj0 = 0 ;
16732 char * kwnames[] = {
16733 (char *) "hsv", NULL
16734 };
16735
16736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16737 {
16738 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16739 if (!SWIG_IsOK(res1)) {
16740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16741 }
16742 if (!argp1) {
16743 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16744 } else {
16745 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16746 arg1 = *temp;
16747 if (SWIG_IsNewObj(res1)) delete temp;
16748 }
16749 }
16750 {
16751 PyThreadState* __tstate = wxPyBeginAllowThreads();
16752 result = wxImage::HSVtoRGB(arg1);
16753 wxPyEndAllowThreads(__tstate);
16754 if (PyErr_Occurred()) SWIG_fail;
16755 }
16756 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16757 return resultobj;
16758 fail:
16759 return NULL;
16760 }
16761
16762
16763 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16764 PyObject *obj;
16765 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16766 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16767 return SWIG_Py_Void();
16768 }
16769
16770 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16771 return SWIG_Python_InitShadowInstance(args);
16772 }
16773
16774 SWIGINTERN int NullImage_set(PyObject *) {
16775 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16776 return 1;
16777 }
16778
16779
16780 SWIGINTERN PyObject *NullImage_get(void) {
16781 PyObject *pyobj = 0;
16782
16783 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16784 return pyobj;
16785 }
16786
16787
16788 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16789 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16790 return 1;
16791 }
16792
16793
16794 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16795 PyObject *pyobj = 0;
16796
16797 {
16798 #if wxUSE_UNICODE
16799 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16800 #else
16801 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16802 #endif
16803 }
16804 return pyobj;
16805 }
16806
16807
16808 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16809 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16810 return 1;
16811 }
16812
16813
16814 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16815 PyObject *pyobj = 0;
16816
16817 {
16818 #if wxUSE_UNICODE
16819 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16820 #else
16821 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16822 #endif
16823 }
16824 return pyobj;
16825 }
16826
16827
16828 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16829 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16830 return 1;
16831 }
16832
16833
16834 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16835 PyObject *pyobj = 0;
16836
16837 {
16838 #if wxUSE_UNICODE
16839 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16840 #else
16841 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16842 #endif
16843 }
16844 return pyobj;
16845 }
16846
16847
16848 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16849 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16850 return 1;
16851 }
16852
16853
16854 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16855 PyObject *pyobj = 0;
16856
16857 {
16858 #if wxUSE_UNICODE
16859 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16860 #else
16861 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16862 #endif
16863 }
16864 return pyobj;
16865 }
16866
16867
16868 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16869 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16870 return 1;
16871 }
16872
16873
16874 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16875 PyObject *pyobj = 0;
16876
16877 {
16878 #if wxUSE_UNICODE
16879 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16880 #else
16881 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16882 #endif
16883 }
16884 return pyobj;
16885 }
16886
16887
16888 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16889 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16890 return 1;
16891 }
16892
16893
16894 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16895 PyObject *pyobj = 0;
16896
16897 {
16898 #if wxUSE_UNICODE
16899 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16900 #else
16901 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16902 #endif
16903 }
16904 return pyobj;
16905 }
16906
16907
16908 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
16909 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
16910 return 1;
16911 }
16912
16913
16914 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
16915 PyObject *pyobj = 0;
16916
16917 {
16918 #if wxUSE_UNICODE
16919 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16920 #else
16921 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16922 #endif
16923 }
16924 return pyobj;
16925 }
16926
16927
16928 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
16929 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
16930 return 1;
16931 }
16932
16933
16934 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
16935 PyObject *pyobj = 0;
16936
16937 {
16938 #if wxUSE_UNICODE
16939 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
16940 #else
16941 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
16942 #endif
16943 }
16944 return pyobj;
16945 }
16946
16947
16948 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
16949 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
16950 return 1;
16951 }
16952
16953
16954 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
16955 PyObject *pyobj = 0;
16956
16957 {
16958 #if wxUSE_UNICODE
16959 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
16960 #else
16961 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
16962 #endif
16963 }
16964 return pyobj;
16965 }
16966
16967
16968 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
16969 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
16970 return 1;
16971 }
16972
16973
16974 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
16975 PyObject *pyobj = 0;
16976
16977 {
16978 #if wxUSE_UNICODE
16979 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
16980 #else
16981 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
16982 #endif
16983 }
16984 return pyobj;
16985 }
16986
16987
16988 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
16989 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
16990 return 1;
16991 }
16992
16993
16994 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
16995 PyObject *pyobj = 0;
16996
16997 {
16998 #if wxUSE_UNICODE
16999 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17000 #else
17001 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17002 #endif
17003 }
17004 return pyobj;
17005 }
17006
17007
17008 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17009 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17010 return 1;
17011 }
17012
17013
17014 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17015 PyObject *pyobj = 0;
17016
17017 {
17018 #if wxUSE_UNICODE
17019 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17020 #else
17021 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17022 #endif
17023 }
17024 return pyobj;
17025 }
17026
17027
17028 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17029 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17030 return 1;
17031 }
17032
17033
17034 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17035 PyObject *pyobj = 0;
17036
17037 {
17038 #if wxUSE_UNICODE
17039 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17040 #else
17041 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17042 #endif
17043 }
17044 return pyobj;
17045 }
17046
17047
17048 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17049 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17050 return 1;
17051 }
17052
17053
17054 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17055 PyObject *pyobj = 0;
17056
17057 {
17058 #if wxUSE_UNICODE
17059 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17060 #else
17061 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17062 #endif
17063 }
17064 return pyobj;
17065 }
17066
17067
17068 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17069 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17070 return 1;
17071 }
17072
17073
17074 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17075 PyObject *pyobj = 0;
17076
17077 {
17078 #if wxUSE_UNICODE
17079 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17080 #else
17081 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17082 #endif
17083 }
17084 return pyobj;
17085 }
17086
17087
17088 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17089 PyObject *resultobj = 0;
17090 wxBMPHandler *result = 0 ;
17091
17092 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17093 {
17094 PyThreadState* __tstate = wxPyBeginAllowThreads();
17095 result = (wxBMPHandler *)new wxBMPHandler();
17096 wxPyEndAllowThreads(__tstate);
17097 if (PyErr_Occurred()) SWIG_fail;
17098 }
17099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17100 return resultobj;
17101 fail:
17102 return NULL;
17103 }
17104
17105
17106 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17107 PyObject *obj;
17108 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17109 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17110 return SWIG_Py_Void();
17111 }
17112
17113 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17114 return SWIG_Python_InitShadowInstance(args);
17115 }
17116
17117 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17118 PyObject *resultobj = 0;
17119 wxICOHandler *result = 0 ;
17120
17121 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17122 {
17123 PyThreadState* __tstate = wxPyBeginAllowThreads();
17124 result = (wxICOHandler *)new wxICOHandler();
17125 wxPyEndAllowThreads(__tstate);
17126 if (PyErr_Occurred()) SWIG_fail;
17127 }
17128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17129 return resultobj;
17130 fail:
17131 return NULL;
17132 }
17133
17134
17135 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17136 PyObject *obj;
17137 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17138 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17139 return SWIG_Py_Void();
17140 }
17141
17142 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17143 return SWIG_Python_InitShadowInstance(args);
17144 }
17145
17146 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17147 PyObject *resultobj = 0;
17148 wxCURHandler *result = 0 ;
17149
17150 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17151 {
17152 PyThreadState* __tstate = wxPyBeginAllowThreads();
17153 result = (wxCURHandler *)new wxCURHandler();
17154 wxPyEndAllowThreads(__tstate);
17155 if (PyErr_Occurred()) SWIG_fail;
17156 }
17157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17158 return resultobj;
17159 fail:
17160 return NULL;
17161 }
17162
17163
17164 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17165 PyObject *obj;
17166 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17167 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17168 return SWIG_Py_Void();
17169 }
17170
17171 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17172 return SWIG_Python_InitShadowInstance(args);
17173 }
17174
17175 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17176 PyObject *resultobj = 0;
17177 wxANIHandler *result = 0 ;
17178
17179 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17180 {
17181 PyThreadState* __tstate = wxPyBeginAllowThreads();
17182 result = (wxANIHandler *)new wxANIHandler();
17183 wxPyEndAllowThreads(__tstate);
17184 if (PyErr_Occurred()) SWIG_fail;
17185 }
17186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17187 return resultobj;
17188 fail:
17189 return NULL;
17190 }
17191
17192
17193 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17194 PyObject *obj;
17195 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17196 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17197 return SWIG_Py_Void();
17198 }
17199
17200 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17201 return SWIG_Python_InitShadowInstance(args);
17202 }
17203
17204 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17205 PyObject *resultobj = 0;
17206 wxPNGHandler *result = 0 ;
17207
17208 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17209 {
17210 PyThreadState* __tstate = wxPyBeginAllowThreads();
17211 result = (wxPNGHandler *)new wxPNGHandler();
17212 wxPyEndAllowThreads(__tstate);
17213 if (PyErr_Occurred()) SWIG_fail;
17214 }
17215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17216 return resultobj;
17217 fail:
17218 return NULL;
17219 }
17220
17221
17222 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17223 PyObject *obj;
17224 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17225 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17226 return SWIG_Py_Void();
17227 }
17228
17229 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17230 return SWIG_Python_InitShadowInstance(args);
17231 }
17232
17233 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17234 PyObject *resultobj = 0;
17235 wxGIFHandler *result = 0 ;
17236
17237 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17238 {
17239 PyThreadState* __tstate = wxPyBeginAllowThreads();
17240 result = (wxGIFHandler *)new wxGIFHandler();
17241 wxPyEndAllowThreads(__tstate);
17242 if (PyErr_Occurred()) SWIG_fail;
17243 }
17244 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17245 return resultobj;
17246 fail:
17247 return NULL;
17248 }
17249
17250
17251 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17252 PyObject *obj;
17253 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17254 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17255 return SWIG_Py_Void();
17256 }
17257
17258 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17259 return SWIG_Python_InitShadowInstance(args);
17260 }
17261
17262 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17263 PyObject *resultobj = 0;
17264 wxPCXHandler *result = 0 ;
17265
17266 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17267 {
17268 PyThreadState* __tstate = wxPyBeginAllowThreads();
17269 result = (wxPCXHandler *)new wxPCXHandler();
17270 wxPyEndAllowThreads(__tstate);
17271 if (PyErr_Occurred()) SWIG_fail;
17272 }
17273 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17274 return resultobj;
17275 fail:
17276 return NULL;
17277 }
17278
17279
17280 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17281 PyObject *obj;
17282 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17283 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17284 return SWIG_Py_Void();
17285 }
17286
17287 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17288 return SWIG_Python_InitShadowInstance(args);
17289 }
17290
17291 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17292 PyObject *resultobj = 0;
17293 wxJPEGHandler *result = 0 ;
17294
17295 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17296 {
17297 PyThreadState* __tstate = wxPyBeginAllowThreads();
17298 result = (wxJPEGHandler *)new wxJPEGHandler();
17299 wxPyEndAllowThreads(__tstate);
17300 if (PyErr_Occurred()) SWIG_fail;
17301 }
17302 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17303 return resultobj;
17304 fail:
17305 return NULL;
17306 }
17307
17308
17309 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17310 PyObject *obj;
17311 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17312 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17313 return SWIG_Py_Void();
17314 }
17315
17316 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17317 return SWIG_Python_InitShadowInstance(args);
17318 }
17319
17320 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17321 PyObject *resultobj = 0;
17322 wxPNMHandler *result = 0 ;
17323
17324 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17325 {
17326 PyThreadState* __tstate = wxPyBeginAllowThreads();
17327 result = (wxPNMHandler *)new wxPNMHandler();
17328 wxPyEndAllowThreads(__tstate);
17329 if (PyErr_Occurred()) SWIG_fail;
17330 }
17331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17332 return resultobj;
17333 fail:
17334 return NULL;
17335 }
17336
17337
17338 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17339 PyObject *obj;
17340 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17341 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17342 return SWIG_Py_Void();
17343 }
17344
17345 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17346 return SWIG_Python_InitShadowInstance(args);
17347 }
17348
17349 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17350 PyObject *resultobj = 0;
17351 wxXPMHandler *result = 0 ;
17352
17353 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17354 {
17355 PyThreadState* __tstate = wxPyBeginAllowThreads();
17356 result = (wxXPMHandler *)new wxXPMHandler();
17357 wxPyEndAllowThreads(__tstate);
17358 if (PyErr_Occurred()) SWIG_fail;
17359 }
17360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17361 return resultobj;
17362 fail:
17363 return NULL;
17364 }
17365
17366
17367 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17368 PyObject *obj;
17369 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17370 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17371 return SWIG_Py_Void();
17372 }
17373
17374 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17375 return SWIG_Python_InitShadowInstance(args);
17376 }
17377
17378 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17379 PyObject *resultobj = 0;
17380 wxTIFFHandler *result = 0 ;
17381
17382 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17383 {
17384 PyThreadState* __tstate = wxPyBeginAllowThreads();
17385 result = (wxTIFFHandler *)new wxTIFFHandler();
17386 wxPyEndAllowThreads(__tstate);
17387 if (PyErr_Occurred()) SWIG_fail;
17388 }
17389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17390 return resultobj;
17391 fail:
17392 return NULL;
17393 }
17394
17395
17396 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17397 PyObject *obj;
17398 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17399 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17400 return SWIG_Py_Void();
17401 }
17402
17403 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17404 return SWIG_Python_InitShadowInstance(args);
17405 }
17406
17407 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17408 PyObject *resultobj = 0;
17409 wxImage *arg1 = 0 ;
17410 wxImage *arg2 = 0 ;
17411 int arg3 = (int) 236 ;
17412 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17413 bool result;
17414 void *argp1 = 0 ;
17415 int res1 = 0 ;
17416 void *argp2 = 0 ;
17417 int res2 = 0 ;
17418 int val3 ;
17419 int ecode3 = 0 ;
17420 int val4 ;
17421 int ecode4 = 0 ;
17422 PyObject * obj0 = 0 ;
17423 PyObject * obj1 = 0 ;
17424 PyObject * obj2 = 0 ;
17425 PyObject * obj3 = 0 ;
17426 char * kwnames[] = {
17427 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17428 };
17429
17430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17431 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17432 if (!SWIG_IsOK(res1)) {
17433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17434 }
17435 if (!argp1) {
17436 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17437 }
17438 arg1 = reinterpret_cast< wxImage * >(argp1);
17439 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17440 if (!SWIG_IsOK(res2)) {
17441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17442 }
17443 if (!argp2) {
17444 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17445 }
17446 arg2 = reinterpret_cast< wxImage * >(argp2);
17447 if (obj2) {
17448 ecode3 = SWIG_AsVal_int(obj2, &val3);
17449 if (!SWIG_IsOK(ecode3)) {
17450 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17451 }
17452 arg3 = static_cast< int >(val3);
17453 }
17454 if (obj3) {
17455 ecode4 = SWIG_AsVal_int(obj3, &val4);
17456 if (!SWIG_IsOK(ecode4)) {
17457 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17458 }
17459 arg4 = static_cast< int >(val4);
17460 }
17461 {
17462 PyThreadState* __tstate = wxPyBeginAllowThreads();
17463 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17464 wxPyEndAllowThreads(__tstate);
17465 if (PyErr_Occurred()) SWIG_fail;
17466 }
17467 {
17468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17469 }
17470 return resultobj;
17471 fail:
17472 return NULL;
17473 }
17474
17475
17476 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17477 PyObject *obj;
17478 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17479 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17480 return SWIG_Py_Void();
17481 }
17482
17483 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17484 PyObject *resultobj = 0;
17485 wxEvtHandler *result = 0 ;
17486
17487 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17488 {
17489 PyThreadState* __tstate = wxPyBeginAllowThreads();
17490 result = (wxEvtHandler *)new wxEvtHandler();
17491 wxPyEndAllowThreads(__tstate);
17492 if (PyErr_Occurred()) SWIG_fail;
17493 }
17494 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17495 return resultobj;
17496 fail:
17497 return NULL;
17498 }
17499
17500
17501 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17502 PyObject *resultobj = 0;
17503 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17504 wxEvtHandler *result = 0 ;
17505 void *argp1 = 0 ;
17506 int res1 = 0 ;
17507 PyObject *swig_obj[1] ;
17508
17509 if (!args) SWIG_fail;
17510 swig_obj[0] = args;
17511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17512 if (!SWIG_IsOK(res1)) {
17513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17514 }
17515 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17516 {
17517 PyThreadState* __tstate = wxPyBeginAllowThreads();
17518 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17519 wxPyEndAllowThreads(__tstate);
17520 if (PyErr_Occurred()) SWIG_fail;
17521 }
17522 {
17523 resultobj = wxPyMake_wxObject(result, 0);
17524 }
17525 return resultobj;
17526 fail:
17527 return NULL;
17528 }
17529
17530
17531 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17532 PyObject *resultobj = 0;
17533 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17534 wxEvtHandler *result = 0 ;
17535 void *argp1 = 0 ;
17536 int res1 = 0 ;
17537 PyObject *swig_obj[1] ;
17538
17539 if (!args) SWIG_fail;
17540 swig_obj[0] = args;
17541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17542 if (!SWIG_IsOK(res1)) {
17543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17544 }
17545 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17546 {
17547 PyThreadState* __tstate = wxPyBeginAllowThreads();
17548 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17549 wxPyEndAllowThreads(__tstate);
17550 if (PyErr_Occurred()) SWIG_fail;
17551 }
17552 {
17553 resultobj = wxPyMake_wxObject(result, 0);
17554 }
17555 return resultobj;
17556 fail:
17557 return NULL;
17558 }
17559
17560
17561 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17562 PyObject *resultobj = 0;
17563 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17564 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17565 void *argp1 = 0 ;
17566 int res1 = 0 ;
17567 void *argp2 = 0 ;
17568 int res2 = 0 ;
17569 PyObject * obj0 = 0 ;
17570 PyObject * obj1 = 0 ;
17571 char * kwnames[] = {
17572 (char *) "self",(char *) "handler", NULL
17573 };
17574
17575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17577 if (!SWIG_IsOK(res1)) {
17578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17579 }
17580 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17581 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17582 if (!SWIG_IsOK(res2)) {
17583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17584 }
17585 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17586 {
17587 PyThreadState* __tstate = wxPyBeginAllowThreads();
17588 (arg1)->SetNextHandler(arg2);
17589 wxPyEndAllowThreads(__tstate);
17590 if (PyErr_Occurred()) SWIG_fail;
17591 }
17592 resultobj = SWIG_Py_Void();
17593 return resultobj;
17594 fail:
17595 return NULL;
17596 }
17597
17598
17599 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17600 PyObject *resultobj = 0;
17601 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17602 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17603 void *argp1 = 0 ;
17604 int res1 = 0 ;
17605 void *argp2 = 0 ;
17606 int res2 = 0 ;
17607 PyObject * obj0 = 0 ;
17608 PyObject * obj1 = 0 ;
17609 char * kwnames[] = {
17610 (char *) "self",(char *) "handler", NULL
17611 };
17612
17613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17615 if (!SWIG_IsOK(res1)) {
17616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17617 }
17618 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17619 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17620 if (!SWIG_IsOK(res2)) {
17621 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17622 }
17623 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17624 {
17625 PyThreadState* __tstate = wxPyBeginAllowThreads();
17626 (arg1)->SetPreviousHandler(arg2);
17627 wxPyEndAllowThreads(__tstate);
17628 if (PyErr_Occurred()) SWIG_fail;
17629 }
17630 resultobj = SWIG_Py_Void();
17631 return resultobj;
17632 fail:
17633 return NULL;
17634 }
17635
17636
17637 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17638 PyObject *resultobj = 0;
17639 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17640 bool result;
17641 void *argp1 = 0 ;
17642 int res1 = 0 ;
17643 PyObject *swig_obj[1] ;
17644
17645 if (!args) SWIG_fail;
17646 swig_obj[0] = args;
17647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17648 if (!SWIG_IsOK(res1)) {
17649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17650 }
17651 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17652 {
17653 PyThreadState* __tstate = wxPyBeginAllowThreads();
17654 result = (bool)(arg1)->GetEvtHandlerEnabled();
17655 wxPyEndAllowThreads(__tstate);
17656 if (PyErr_Occurred()) SWIG_fail;
17657 }
17658 {
17659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17660 }
17661 return resultobj;
17662 fail:
17663 return NULL;
17664 }
17665
17666
17667 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17668 PyObject *resultobj = 0;
17669 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17670 bool arg2 ;
17671 void *argp1 = 0 ;
17672 int res1 = 0 ;
17673 bool val2 ;
17674 int ecode2 = 0 ;
17675 PyObject * obj0 = 0 ;
17676 PyObject * obj1 = 0 ;
17677 char * kwnames[] = {
17678 (char *) "self",(char *) "enabled", NULL
17679 };
17680
17681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17683 if (!SWIG_IsOK(res1)) {
17684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17685 }
17686 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17687 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17688 if (!SWIG_IsOK(ecode2)) {
17689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17690 }
17691 arg2 = static_cast< bool >(val2);
17692 {
17693 PyThreadState* __tstate = wxPyBeginAllowThreads();
17694 (arg1)->SetEvtHandlerEnabled(arg2);
17695 wxPyEndAllowThreads(__tstate);
17696 if (PyErr_Occurred()) SWIG_fail;
17697 }
17698 resultobj = SWIG_Py_Void();
17699 return resultobj;
17700 fail:
17701 return NULL;
17702 }
17703
17704
17705 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17706 PyObject *resultobj = 0;
17707 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17708 wxEvent *arg2 = 0 ;
17709 bool result;
17710 void *argp1 = 0 ;
17711 int res1 = 0 ;
17712 void *argp2 = 0 ;
17713 int res2 = 0 ;
17714 PyObject * obj0 = 0 ;
17715 PyObject * obj1 = 0 ;
17716 char * kwnames[] = {
17717 (char *) "self",(char *) "event", NULL
17718 };
17719
17720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17722 if (!SWIG_IsOK(res1)) {
17723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17724 }
17725 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17726 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17727 if (!SWIG_IsOK(res2)) {
17728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17729 }
17730 if (!argp2) {
17731 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17732 }
17733 arg2 = reinterpret_cast< wxEvent * >(argp2);
17734 {
17735 PyThreadState* __tstate = wxPyBeginAllowThreads();
17736 result = (bool)(arg1)->ProcessEvent(*arg2);
17737 wxPyEndAllowThreads(__tstate);
17738 if (PyErr_Occurred()) SWIG_fail;
17739 }
17740 {
17741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17742 }
17743 return resultobj;
17744 fail:
17745 return NULL;
17746 }
17747
17748
17749 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17750 PyObject *resultobj = 0;
17751 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17752 wxEvent *arg2 = 0 ;
17753 void *argp1 = 0 ;
17754 int res1 = 0 ;
17755 void *argp2 = 0 ;
17756 int res2 = 0 ;
17757 PyObject * obj0 = 0 ;
17758 PyObject * obj1 = 0 ;
17759 char * kwnames[] = {
17760 (char *) "self",(char *) "event", NULL
17761 };
17762
17763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17765 if (!SWIG_IsOK(res1)) {
17766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17767 }
17768 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17769 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17770 if (!SWIG_IsOK(res2)) {
17771 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17772 }
17773 if (!argp2) {
17774 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17775 }
17776 arg2 = reinterpret_cast< wxEvent * >(argp2);
17777 {
17778 PyThreadState* __tstate = wxPyBeginAllowThreads();
17779 (arg1)->AddPendingEvent(*arg2);
17780 wxPyEndAllowThreads(__tstate);
17781 if (PyErr_Occurred()) SWIG_fail;
17782 }
17783 resultobj = SWIG_Py_Void();
17784 return resultobj;
17785 fail:
17786 return NULL;
17787 }
17788
17789
17790 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17791 PyObject *resultobj = 0;
17792 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17793 void *argp1 = 0 ;
17794 int res1 = 0 ;
17795 PyObject *swig_obj[1] ;
17796
17797 if (!args) SWIG_fail;
17798 swig_obj[0] = args;
17799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17800 if (!SWIG_IsOK(res1)) {
17801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17802 }
17803 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17804 {
17805 PyThreadState* __tstate = wxPyBeginAllowThreads();
17806 (arg1)->ProcessPendingEvents();
17807 wxPyEndAllowThreads(__tstate);
17808 if (PyErr_Occurred()) SWIG_fail;
17809 }
17810 resultobj = SWIG_Py_Void();
17811 return resultobj;
17812 fail:
17813 return NULL;
17814 }
17815
17816
17817 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17818 PyObject *resultobj = 0;
17819 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17820 int arg2 ;
17821 int arg3 ;
17822 int arg4 ;
17823 PyObject *arg5 = (PyObject *) 0 ;
17824 void *argp1 = 0 ;
17825 int res1 = 0 ;
17826 int val2 ;
17827 int ecode2 = 0 ;
17828 int val3 ;
17829 int ecode3 = 0 ;
17830 int val4 ;
17831 int ecode4 = 0 ;
17832 PyObject * obj0 = 0 ;
17833 PyObject * obj1 = 0 ;
17834 PyObject * obj2 = 0 ;
17835 PyObject * obj3 = 0 ;
17836 PyObject * obj4 = 0 ;
17837 char * kwnames[] = {
17838 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17839 };
17840
17841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17843 if (!SWIG_IsOK(res1)) {
17844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17845 }
17846 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17847 ecode2 = SWIG_AsVal_int(obj1, &val2);
17848 if (!SWIG_IsOK(ecode2)) {
17849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17850 }
17851 arg2 = static_cast< int >(val2);
17852 ecode3 = SWIG_AsVal_int(obj2, &val3);
17853 if (!SWIG_IsOK(ecode3)) {
17854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17855 }
17856 arg3 = static_cast< int >(val3);
17857 ecode4 = SWIG_AsVal_int(obj3, &val4);
17858 if (!SWIG_IsOK(ecode4)) {
17859 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17860 }
17861 arg4 = static_cast< int >(val4);
17862 arg5 = obj4;
17863 {
17864 PyThreadState* __tstate = wxPyBeginAllowThreads();
17865 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17866 wxPyEndAllowThreads(__tstate);
17867 if (PyErr_Occurred()) SWIG_fail;
17868 }
17869 resultobj = SWIG_Py_Void();
17870 return resultobj;
17871 fail:
17872 return NULL;
17873 }
17874
17875
17876 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17877 PyObject *resultobj = 0;
17878 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17879 int arg2 ;
17880 int arg3 = (int) -1 ;
17881 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17882 bool result;
17883 void *argp1 = 0 ;
17884 int res1 = 0 ;
17885 int val2 ;
17886 int ecode2 = 0 ;
17887 int val3 ;
17888 int ecode3 = 0 ;
17889 int val4 ;
17890 int ecode4 = 0 ;
17891 PyObject * obj0 = 0 ;
17892 PyObject * obj1 = 0 ;
17893 PyObject * obj2 = 0 ;
17894 PyObject * obj3 = 0 ;
17895 char * kwnames[] = {
17896 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17897 };
17898
17899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17901 if (!SWIG_IsOK(res1)) {
17902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17903 }
17904 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17905 ecode2 = SWIG_AsVal_int(obj1, &val2);
17906 if (!SWIG_IsOK(ecode2)) {
17907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
17908 }
17909 arg2 = static_cast< int >(val2);
17910 if (obj2) {
17911 ecode3 = SWIG_AsVal_int(obj2, &val3);
17912 if (!SWIG_IsOK(ecode3)) {
17913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
17914 }
17915 arg3 = static_cast< int >(val3);
17916 }
17917 if (obj3) {
17918 ecode4 = SWIG_AsVal_int(obj3, &val4);
17919 if (!SWIG_IsOK(ecode4)) {
17920 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
17921 }
17922 arg4 = static_cast< wxEventType >(val4);
17923 }
17924 {
17925 PyThreadState* __tstate = wxPyBeginAllowThreads();
17926 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
17927 wxPyEndAllowThreads(__tstate);
17928 if (PyErr_Occurred()) SWIG_fail;
17929 }
17930 {
17931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17932 }
17933 return resultobj;
17934 fail:
17935 return NULL;
17936 }
17937
17938
17939 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17940 PyObject *resultobj = 0;
17941 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17942 PyObject *arg2 = (PyObject *) 0 ;
17943 bool arg3 = (bool) true ;
17944 void *argp1 = 0 ;
17945 int res1 = 0 ;
17946 bool val3 ;
17947 int ecode3 = 0 ;
17948 PyObject * obj0 = 0 ;
17949 PyObject * obj1 = 0 ;
17950 PyObject * obj2 = 0 ;
17951 char * kwnames[] = {
17952 (char *) "self",(char *) "_self",(char *) "incref", NULL
17953 };
17954
17955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17957 if (!SWIG_IsOK(res1)) {
17958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17959 }
17960 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17961 arg2 = obj1;
17962 if (obj2) {
17963 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17964 if (!SWIG_IsOK(ecode3)) {
17965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
17966 }
17967 arg3 = static_cast< bool >(val3);
17968 }
17969 {
17970 PyThreadState* __tstate = wxPyBeginAllowThreads();
17971 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
17972 wxPyEndAllowThreads(__tstate);
17973 if (PyErr_Occurred()) SWIG_fail;
17974 }
17975 resultobj = SWIG_Py_Void();
17976 return resultobj;
17977 fail:
17978 return NULL;
17979 }
17980
17981
17982 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17983 PyObject *obj;
17984 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17985 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
17986 return SWIG_Py_Void();
17987 }
17988
17989 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17990 return SWIG_Python_InitShadowInstance(args);
17991 }
17992
17993 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17994 PyObject *resultobj = 0;
17995 wxEventType result;
17996
17997 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
17998 {
17999 PyThreadState* __tstate = wxPyBeginAllowThreads();
18000 result = (wxEventType)wxNewEventType();
18001 wxPyEndAllowThreads(__tstate);
18002 if (PyErr_Occurred()) SWIG_fail;
18003 }
18004 resultobj = SWIG_From_int(static_cast< int >(result));
18005 return resultobj;
18006 fail:
18007 return NULL;
18008 }
18009
18010
18011 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18012 PyObject *resultobj = 0;
18013 wxEvent *arg1 = (wxEvent *) 0 ;
18014 void *argp1 = 0 ;
18015 int res1 = 0 ;
18016 PyObject *swig_obj[1] ;
18017
18018 if (!args) SWIG_fail;
18019 swig_obj[0] = args;
18020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18021 if (!SWIG_IsOK(res1)) {
18022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18023 }
18024 arg1 = reinterpret_cast< wxEvent * >(argp1);
18025 {
18026 PyThreadState* __tstate = wxPyBeginAllowThreads();
18027 delete arg1;
18028
18029 wxPyEndAllowThreads(__tstate);
18030 if (PyErr_Occurred()) SWIG_fail;
18031 }
18032 resultobj = SWIG_Py_Void();
18033 return resultobj;
18034 fail:
18035 return NULL;
18036 }
18037
18038
18039 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18040 PyObject *resultobj = 0;
18041 wxEvent *arg1 = (wxEvent *) 0 ;
18042 wxEventType arg2 ;
18043 void *argp1 = 0 ;
18044 int res1 = 0 ;
18045 int val2 ;
18046 int ecode2 = 0 ;
18047 PyObject * obj0 = 0 ;
18048 PyObject * obj1 = 0 ;
18049 char * kwnames[] = {
18050 (char *) "self",(char *) "typ", NULL
18051 };
18052
18053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18055 if (!SWIG_IsOK(res1)) {
18056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18057 }
18058 arg1 = reinterpret_cast< wxEvent * >(argp1);
18059 ecode2 = SWIG_AsVal_int(obj1, &val2);
18060 if (!SWIG_IsOK(ecode2)) {
18061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18062 }
18063 arg2 = static_cast< wxEventType >(val2);
18064 {
18065 PyThreadState* __tstate = wxPyBeginAllowThreads();
18066 (arg1)->SetEventType(arg2);
18067 wxPyEndAllowThreads(__tstate);
18068 if (PyErr_Occurred()) SWIG_fail;
18069 }
18070 resultobj = SWIG_Py_Void();
18071 return resultobj;
18072 fail:
18073 return NULL;
18074 }
18075
18076
18077 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18078 PyObject *resultobj = 0;
18079 wxEvent *arg1 = (wxEvent *) 0 ;
18080 wxEventType result;
18081 void *argp1 = 0 ;
18082 int res1 = 0 ;
18083 PyObject *swig_obj[1] ;
18084
18085 if (!args) SWIG_fail;
18086 swig_obj[0] = args;
18087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18088 if (!SWIG_IsOK(res1)) {
18089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18090 }
18091 arg1 = reinterpret_cast< wxEvent * >(argp1);
18092 {
18093 PyThreadState* __tstate = wxPyBeginAllowThreads();
18094 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18095 wxPyEndAllowThreads(__tstate);
18096 if (PyErr_Occurred()) SWIG_fail;
18097 }
18098 resultobj = SWIG_From_int(static_cast< int >(result));
18099 return resultobj;
18100 fail:
18101 return NULL;
18102 }
18103
18104
18105 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18106 PyObject *resultobj = 0;
18107 wxEvent *arg1 = (wxEvent *) 0 ;
18108 wxObject *result = 0 ;
18109 void *argp1 = 0 ;
18110 int res1 = 0 ;
18111 PyObject *swig_obj[1] ;
18112
18113 if (!args) SWIG_fail;
18114 swig_obj[0] = args;
18115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18116 if (!SWIG_IsOK(res1)) {
18117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18118 }
18119 arg1 = reinterpret_cast< wxEvent * >(argp1);
18120 {
18121 PyThreadState* __tstate = wxPyBeginAllowThreads();
18122 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18123 wxPyEndAllowThreads(__tstate);
18124 if (PyErr_Occurred()) SWIG_fail;
18125 }
18126 {
18127 resultobj = wxPyMake_wxObject(result, (bool)0);
18128 }
18129 return resultobj;
18130 fail:
18131 return NULL;
18132 }
18133
18134
18135 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18136 PyObject *resultobj = 0;
18137 wxEvent *arg1 = (wxEvent *) 0 ;
18138 wxObject *arg2 = (wxObject *) 0 ;
18139 void *argp1 = 0 ;
18140 int res1 = 0 ;
18141 void *argp2 = 0 ;
18142 int res2 = 0 ;
18143 PyObject * obj0 = 0 ;
18144 PyObject * obj1 = 0 ;
18145 char * kwnames[] = {
18146 (char *) "self",(char *) "obj", NULL
18147 };
18148
18149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18151 if (!SWIG_IsOK(res1)) {
18152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18153 }
18154 arg1 = reinterpret_cast< wxEvent * >(argp1);
18155 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18156 if (!SWIG_IsOK(res2)) {
18157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18158 }
18159 arg2 = reinterpret_cast< wxObject * >(argp2);
18160 {
18161 PyThreadState* __tstate = wxPyBeginAllowThreads();
18162 (arg1)->SetEventObject(arg2);
18163 wxPyEndAllowThreads(__tstate);
18164 if (PyErr_Occurred()) SWIG_fail;
18165 }
18166 resultobj = SWIG_Py_Void();
18167 return resultobj;
18168 fail:
18169 return NULL;
18170 }
18171
18172
18173 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18174 PyObject *resultobj = 0;
18175 wxEvent *arg1 = (wxEvent *) 0 ;
18176 long result;
18177 void *argp1 = 0 ;
18178 int res1 = 0 ;
18179 PyObject *swig_obj[1] ;
18180
18181 if (!args) SWIG_fail;
18182 swig_obj[0] = args;
18183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18184 if (!SWIG_IsOK(res1)) {
18185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18186 }
18187 arg1 = reinterpret_cast< wxEvent * >(argp1);
18188 {
18189 PyThreadState* __tstate = wxPyBeginAllowThreads();
18190 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18191 wxPyEndAllowThreads(__tstate);
18192 if (PyErr_Occurred()) SWIG_fail;
18193 }
18194 resultobj = SWIG_From_long(static_cast< long >(result));
18195 return resultobj;
18196 fail:
18197 return NULL;
18198 }
18199
18200
18201 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18202 PyObject *resultobj = 0;
18203 wxEvent *arg1 = (wxEvent *) 0 ;
18204 long arg2 = (long) 0 ;
18205 void *argp1 = 0 ;
18206 int res1 = 0 ;
18207 long val2 ;
18208 int ecode2 = 0 ;
18209 PyObject * obj0 = 0 ;
18210 PyObject * obj1 = 0 ;
18211 char * kwnames[] = {
18212 (char *) "self",(char *) "ts", NULL
18213 };
18214
18215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18217 if (!SWIG_IsOK(res1)) {
18218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18219 }
18220 arg1 = reinterpret_cast< wxEvent * >(argp1);
18221 if (obj1) {
18222 ecode2 = SWIG_AsVal_long(obj1, &val2);
18223 if (!SWIG_IsOK(ecode2)) {
18224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18225 }
18226 arg2 = static_cast< long >(val2);
18227 }
18228 {
18229 PyThreadState* __tstate = wxPyBeginAllowThreads();
18230 (arg1)->SetTimestamp(arg2);
18231 wxPyEndAllowThreads(__tstate);
18232 if (PyErr_Occurred()) SWIG_fail;
18233 }
18234 resultobj = SWIG_Py_Void();
18235 return resultobj;
18236 fail:
18237 return NULL;
18238 }
18239
18240
18241 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18242 PyObject *resultobj = 0;
18243 wxEvent *arg1 = (wxEvent *) 0 ;
18244 int result;
18245 void *argp1 = 0 ;
18246 int res1 = 0 ;
18247 PyObject *swig_obj[1] ;
18248
18249 if (!args) SWIG_fail;
18250 swig_obj[0] = args;
18251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18252 if (!SWIG_IsOK(res1)) {
18253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18254 }
18255 arg1 = reinterpret_cast< wxEvent * >(argp1);
18256 {
18257 PyThreadState* __tstate = wxPyBeginAllowThreads();
18258 result = (int)((wxEvent const *)arg1)->GetId();
18259 wxPyEndAllowThreads(__tstate);
18260 if (PyErr_Occurred()) SWIG_fail;
18261 }
18262 resultobj = SWIG_From_int(static_cast< int >(result));
18263 return resultobj;
18264 fail:
18265 return NULL;
18266 }
18267
18268
18269 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18270 PyObject *resultobj = 0;
18271 wxEvent *arg1 = (wxEvent *) 0 ;
18272 int arg2 ;
18273 void *argp1 = 0 ;
18274 int res1 = 0 ;
18275 int val2 ;
18276 int ecode2 = 0 ;
18277 PyObject * obj0 = 0 ;
18278 PyObject * obj1 = 0 ;
18279 char * kwnames[] = {
18280 (char *) "self",(char *) "Id", NULL
18281 };
18282
18283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18285 if (!SWIG_IsOK(res1)) {
18286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18287 }
18288 arg1 = reinterpret_cast< wxEvent * >(argp1);
18289 ecode2 = SWIG_AsVal_int(obj1, &val2);
18290 if (!SWIG_IsOK(ecode2)) {
18291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18292 }
18293 arg2 = static_cast< int >(val2);
18294 {
18295 PyThreadState* __tstate = wxPyBeginAllowThreads();
18296 (arg1)->SetId(arg2);
18297 wxPyEndAllowThreads(__tstate);
18298 if (PyErr_Occurred()) SWIG_fail;
18299 }
18300 resultobj = SWIG_Py_Void();
18301 return resultobj;
18302 fail:
18303 return NULL;
18304 }
18305
18306
18307 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18308 PyObject *resultobj = 0;
18309 wxEvent *arg1 = (wxEvent *) 0 ;
18310 bool result;
18311 void *argp1 = 0 ;
18312 int res1 = 0 ;
18313 PyObject *swig_obj[1] ;
18314
18315 if (!args) SWIG_fail;
18316 swig_obj[0] = args;
18317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18318 if (!SWIG_IsOK(res1)) {
18319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18320 }
18321 arg1 = reinterpret_cast< wxEvent * >(argp1);
18322 {
18323 PyThreadState* __tstate = wxPyBeginAllowThreads();
18324 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18325 wxPyEndAllowThreads(__tstate);
18326 if (PyErr_Occurred()) SWIG_fail;
18327 }
18328 {
18329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18330 }
18331 return resultobj;
18332 fail:
18333 return NULL;
18334 }
18335
18336
18337 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18338 PyObject *resultobj = 0;
18339 wxEvent *arg1 = (wxEvent *) 0 ;
18340 bool arg2 = (bool) true ;
18341 void *argp1 = 0 ;
18342 int res1 = 0 ;
18343 bool val2 ;
18344 int ecode2 = 0 ;
18345 PyObject * obj0 = 0 ;
18346 PyObject * obj1 = 0 ;
18347 char * kwnames[] = {
18348 (char *) "self",(char *) "skip", NULL
18349 };
18350
18351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18353 if (!SWIG_IsOK(res1)) {
18354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18355 }
18356 arg1 = reinterpret_cast< wxEvent * >(argp1);
18357 if (obj1) {
18358 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18359 if (!SWIG_IsOK(ecode2)) {
18360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18361 }
18362 arg2 = static_cast< bool >(val2);
18363 }
18364 {
18365 PyThreadState* __tstate = wxPyBeginAllowThreads();
18366 (arg1)->Skip(arg2);
18367 wxPyEndAllowThreads(__tstate);
18368 if (PyErr_Occurred()) SWIG_fail;
18369 }
18370 resultobj = SWIG_Py_Void();
18371 return resultobj;
18372 fail:
18373 return NULL;
18374 }
18375
18376
18377 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18378 PyObject *resultobj = 0;
18379 wxEvent *arg1 = (wxEvent *) 0 ;
18380 bool result;
18381 void *argp1 = 0 ;
18382 int res1 = 0 ;
18383 PyObject *swig_obj[1] ;
18384
18385 if (!args) SWIG_fail;
18386 swig_obj[0] = args;
18387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18388 if (!SWIG_IsOK(res1)) {
18389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18390 }
18391 arg1 = reinterpret_cast< wxEvent * >(argp1);
18392 {
18393 PyThreadState* __tstate = wxPyBeginAllowThreads();
18394 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18395 wxPyEndAllowThreads(__tstate);
18396 if (PyErr_Occurred()) SWIG_fail;
18397 }
18398 {
18399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18400 }
18401 return resultobj;
18402 fail:
18403 return NULL;
18404 }
18405
18406
18407 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18408 PyObject *resultobj = 0;
18409 wxEvent *arg1 = (wxEvent *) 0 ;
18410 bool result;
18411 void *argp1 = 0 ;
18412 int res1 = 0 ;
18413 PyObject *swig_obj[1] ;
18414
18415 if (!args) SWIG_fail;
18416 swig_obj[0] = args;
18417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18418 if (!SWIG_IsOK(res1)) {
18419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18420 }
18421 arg1 = reinterpret_cast< wxEvent * >(argp1);
18422 {
18423 PyThreadState* __tstate = wxPyBeginAllowThreads();
18424 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18425 wxPyEndAllowThreads(__tstate);
18426 if (PyErr_Occurred()) SWIG_fail;
18427 }
18428 {
18429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18430 }
18431 return resultobj;
18432 fail:
18433 return NULL;
18434 }
18435
18436
18437 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18438 PyObject *resultobj = 0;
18439 wxEvent *arg1 = (wxEvent *) 0 ;
18440 int result;
18441 void *argp1 = 0 ;
18442 int res1 = 0 ;
18443 PyObject *swig_obj[1] ;
18444
18445 if (!args) SWIG_fail;
18446 swig_obj[0] = args;
18447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18448 if (!SWIG_IsOK(res1)) {
18449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18450 }
18451 arg1 = reinterpret_cast< wxEvent * >(argp1);
18452 {
18453 PyThreadState* __tstate = wxPyBeginAllowThreads();
18454 result = (int)(arg1)->StopPropagation();
18455 wxPyEndAllowThreads(__tstate);
18456 if (PyErr_Occurred()) SWIG_fail;
18457 }
18458 resultobj = SWIG_From_int(static_cast< int >(result));
18459 return resultobj;
18460 fail:
18461 return NULL;
18462 }
18463
18464
18465 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18466 PyObject *resultobj = 0;
18467 wxEvent *arg1 = (wxEvent *) 0 ;
18468 int arg2 ;
18469 void *argp1 = 0 ;
18470 int res1 = 0 ;
18471 int val2 ;
18472 int ecode2 = 0 ;
18473 PyObject * obj0 = 0 ;
18474 PyObject * obj1 = 0 ;
18475 char * kwnames[] = {
18476 (char *) "self",(char *) "propagationLevel", NULL
18477 };
18478
18479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18481 if (!SWIG_IsOK(res1)) {
18482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18483 }
18484 arg1 = reinterpret_cast< wxEvent * >(argp1);
18485 ecode2 = SWIG_AsVal_int(obj1, &val2);
18486 if (!SWIG_IsOK(ecode2)) {
18487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18488 }
18489 arg2 = static_cast< int >(val2);
18490 {
18491 PyThreadState* __tstate = wxPyBeginAllowThreads();
18492 (arg1)->ResumePropagation(arg2);
18493 wxPyEndAllowThreads(__tstate);
18494 if (PyErr_Occurred()) SWIG_fail;
18495 }
18496 resultobj = SWIG_Py_Void();
18497 return resultobj;
18498 fail:
18499 return NULL;
18500 }
18501
18502
18503 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18504 PyObject *resultobj = 0;
18505 wxEvent *arg1 = (wxEvent *) 0 ;
18506 wxEvent *result = 0 ;
18507 void *argp1 = 0 ;
18508 int res1 = 0 ;
18509 PyObject *swig_obj[1] ;
18510
18511 if (!args) SWIG_fail;
18512 swig_obj[0] = args;
18513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18514 if (!SWIG_IsOK(res1)) {
18515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18516 }
18517 arg1 = reinterpret_cast< wxEvent * >(argp1);
18518 {
18519 PyThreadState* __tstate = wxPyBeginAllowThreads();
18520 result = (wxEvent *)(arg1)->Clone();
18521 wxPyEndAllowThreads(__tstate);
18522 if (PyErr_Occurred()) SWIG_fail;
18523 }
18524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18525 return resultobj;
18526 fail:
18527 return NULL;
18528 }
18529
18530
18531 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18532 PyObject *obj;
18533 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18534 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18535 return SWIG_Py_Void();
18536 }
18537
18538 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18539 PyObject *resultobj = 0;
18540 wxEvent *arg1 = 0 ;
18541 wxPropagationDisabler *result = 0 ;
18542 void *argp1 = 0 ;
18543 int res1 = 0 ;
18544 PyObject * obj0 = 0 ;
18545 char * kwnames[] = {
18546 (char *) "event", NULL
18547 };
18548
18549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18550 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18551 if (!SWIG_IsOK(res1)) {
18552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18553 }
18554 if (!argp1) {
18555 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18556 }
18557 arg1 = reinterpret_cast< wxEvent * >(argp1);
18558 {
18559 PyThreadState* __tstate = wxPyBeginAllowThreads();
18560 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18561 wxPyEndAllowThreads(__tstate);
18562 if (PyErr_Occurred()) SWIG_fail;
18563 }
18564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18565 return resultobj;
18566 fail:
18567 return NULL;
18568 }
18569
18570
18571 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18572 PyObject *resultobj = 0;
18573 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18574 void *argp1 = 0 ;
18575 int res1 = 0 ;
18576 PyObject *swig_obj[1] ;
18577
18578 if (!args) SWIG_fail;
18579 swig_obj[0] = args;
18580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18581 if (!SWIG_IsOK(res1)) {
18582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18583 }
18584 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18585 {
18586 PyThreadState* __tstate = wxPyBeginAllowThreads();
18587 delete arg1;
18588
18589 wxPyEndAllowThreads(__tstate);
18590 if (PyErr_Occurred()) SWIG_fail;
18591 }
18592 resultobj = SWIG_Py_Void();
18593 return resultobj;
18594 fail:
18595 return NULL;
18596 }
18597
18598
18599 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18600 PyObject *obj;
18601 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18602 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18603 return SWIG_Py_Void();
18604 }
18605
18606 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18607 return SWIG_Python_InitShadowInstance(args);
18608 }
18609
18610 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18611 PyObject *resultobj = 0;
18612 wxEvent *arg1 = 0 ;
18613 wxPropagateOnce *result = 0 ;
18614 void *argp1 = 0 ;
18615 int res1 = 0 ;
18616 PyObject * obj0 = 0 ;
18617 char * kwnames[] = {
18618 (char *) "event", NULL
18619 };
18620
18621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18622 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18623 if (!SWIG_IsOK(res1)) {
18624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18625 }
18626 if (!argp1) {
18627 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18628 }
18629 arg1 = reinterpret_cast< wxEvent * >(argp1);
18630 {
18631 PyThreadState* __tstate = wxPyBeginAllowThreads();
18632 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18633 wxPyEndAllowThreads(__tstate);
18634 if (PyErr_Occurred()) SWIG_fail;
18635 }
18636 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18637 return resultobj;
18638 fail:
18639 return NULL;
18640 }
18641
18642
18643 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18644 PyObject *resultobj = 0;
18645 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18646 void *argp1 = 0 ;
18647 int res1 = 0 ;
18648 PyObject *swig_obj[1] ;
18649
18650 if (!args) SWIG_fail;
18651 swig_obj[0] = args;
18652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18653 if (!SWIG_IsOK(res1)) {
18654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18655 }
18656 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18657 {
18658 PyThreadState* __tstate = wxPyBeginAllowThreads();
18659 delete arg1;
18660
18661 wxPyEndAllowThreads(__tstate);
18662 if (PyErr_Occurred()) SWIG_fail;
18663 }
18664 resultobj = SWIG_Py_Void();
18665 return resultobj;
18666 fail:
18667 return NULL;
18668 }
18669
18670
18671 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18672 PyObject *obj;
18673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18674 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18675 return SWIG_Py_Void();
18676 }
18677
18678 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18679 return SWIG_Python_InitShadowInstance(args);
18680 }
18681
18682 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18683 PyObject *resultobj = 0;
18684 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18685 int arg2 = (int) 0 ;
18686 wxCommandEvent *result = 0 ;
18687 int val1 ;
18688 int ecode1 = 0 ;
18689 int val2 ;
18690 int ecode2 = 0 ;
18691 PyObject * obj0 = 0 ;
18692 PyObject * obj1 = 0 ;
18693 char * kwnames[] = {
18694 (char *) "commandType",(char *) "winid", NULL
18695 };
18696
18697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18698 if (obj0) {
18699 ecode1 = SWIG_AsVal_int(obj0, &val1);
18700 if (!SWIG_IsOK(ecode1)) {
18701 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18702 }
18703 arg1 = static_cast< wxEventType >(val1);
18704 }
18705 if (obj1) {
18706 ecode2 = SWIG_AsVal_int(obj1, &val2);
18707 if (!SWIG_IsOK(ecode2)) {
18708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18709 }
18710 arg2 = static_cast< int >(val2);
18711 }
18712 {
18713 PyThreadState* __tstate = wxPyBeginAllowThreads();
18714 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18715 wxPyEndAllowThreads(__tstate);
18716 if (PyErr_Occurred()) SWIG_fail;
18717 }
18718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18719 return resultobj;
18720 fail:
18721 return NULL;
18722 }
18723
18724
18725 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18726 PyObject *resultobj = 0;
18727 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18728 int result;
18729 void *argp1 = 0 ;
18730 int res1 = 0 ;
18731 PyObject *swig_obj[1] ;
18732
18733 if (!args) SWIG_fail;
18734 swig_obj[0] = args;
18735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18736 if (!SWIG_IsOK(res1)) {
18737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18738 }
18739 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18740 {
18741 PyThreadState* __tstate = wxPyBeginAllowThreads();
18742 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18743 wxPyEndAllowThreads(__tstate);
18744 if (PyErr_Occurred()) SWIG_fail;
18745 }
18746 resultobj = SWIG_From_int(static_cast< int >(result));
18747 return resultobj;
18748 fail:
18749 return NULL;
18750 }
18751
18752
18753 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18754 PyObject *resultobj = 0;
18755 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18756 wxString *arg2 = 0 ;
18757 void *argp1 = 0 ;
18758 int res1 = 0 ;
18759 bool temp2 = false ;
18760 PyObject * obj0 = 0 ;
18761 PyObject * obj1 = 0 ;
18762 char * kwnames[] = {
18763 (char *) "self",(char *) "s", NULL
18764 };
18765
18766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18768 if (!SWIG_IsOK(res1)) {
18769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18770 }
18771 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18772 {
18773 arg2 = wxString_in_helper(obj1);
18774 if (arg2 == NULL) SWIG_fail;
18775 temp2 = true;
18776 }
18777 {
18778 PyThreadState* __tstate = wxPyBeginAllowThreads();
18779 (arg1)->SetString((wxString const &)*arg2);
18780 wxPyEndAllowThreads(__tstate);
18781 if (PyErr_Occurred()) SWIG_fail;
18782 }
18783 resultobj = SWIG_Py_Void();
18784 {
18785 if (temp2)
18786 delete arg2;
18787 }
18788 return resultobj;
18789 fail:
18790 {
18791 if (temp2)
18792 delete arg2;
18793 }
18794 return NULL;
18795 }
18796
18797
18798 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18799 PyObject *resultobj = 0;
18800 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18801 wxString result;
18802 void *argp1 = 0 ;
18803 int res1 = 0 ;
18804 PyObject *swig_obj[1] ;
18805
18806 if (!args) SWIG_fail;
18807 swig_obj[0] = args;
18808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18809 if (!SWIG_IsOK(res1)) {
18810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18811 }
18812 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18813 {
18814 PyThreadState* __tstate = wxPyBeginAllowThreads();
18815 result = ((wxCommandEvent const *)arg1)->GetString();
18816 wxPyEndAllowThreads(__tstate);
18817 if (PyErr_Occurred()) SWIG_fail;
18818 }
18819 {
18820 #if wxUSE_UNICODE
18821 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18822 #else
18823 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18824 #endif
18825 }
18826 return resultobj;
18827 fail:
18828 return NULL;
18829 }
18830
18831
18832 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18833 PyObject *resultobj = 0;
18834 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18835 bool result;
18836 void *argp1 = 0 ;
18837 int res1 = 0 ;
18838 PyObject *swig_obj[1] ;
18839
18840 if (!args) SWIG_fail;
18841 swig_obj[0] = args;
18842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18843 if (!SWIG_IsOK(res1)) {
18844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18845 }
18846 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18847 {
18848 PyThreadState* __tstate = wxPyBeginAllowThreads();
18849 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18850 wxPyEndAllowThreads(__tstate);
18851 if (PyErr_Occurred()) SWIG_fail;
18852 }
18853 {
18854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18855 }
18856 return resultobj;
18857 fail:
18858 return NULL;
18859 }
18860
18861
18862 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18863 PyObject *resultobj = 0;
18864 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18865 bool result;
18866 void *argp1 = 0 ;
18867 int res1 = 0 ;
18868 PyObject *swig_obj[1] ;
18869
18870 if (!args) SWIG_fail;
18871 swig_obj[0] = args;
18872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18873 if (!SWIG_IsOK(res1)) {
18874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18875 }
18876 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18877 {
18878 PyThreadState* __tstate = wxPyBeginAllowThreads();
18879 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18880 wxPyEndAllowThreads(__tstate);
18881 if (PyErr_Occurred()) SWIG_fail;
18882 }
18883 {
18884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18885 }
18886 return resultobj;
18887 fail:
18888 return NULL;
18889 }
18890
18891
18892 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18893 PyObject *resultobj = 0;
18894 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18895 long arg2 ;
18896 void *argp1 = 0 ;
18897 int res1 = 0 ;
18898 long val2 ;
18899 int ecode2 = 0 ;
18900 PyObject * obj0 = 0 ;
18901 PyObject * obj1 = 0 ;
18902 char * kwnames[] = {
18903 (char *) "self",(char *) "extraLong", NULL
18904 };
18905
18906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
18907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18908 if (!SWIG_IsOK(res1)) {
18909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18910 }
18911 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18912 ecode2 = SWIG_AsVal_long(obj1, &val2);
18913 if (!SWIG_IsOK(ecode2)) {
18914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
18915 }
18916 arg2 = static_cast< long >(val2);
18917 {
18918 PyThreadState* __tstate = wxPyBeginAllowThreads();
18919 (arg1)->SetExtraLong(arg2);
18920 wxPyEndAllowThreads(__tstate);
18921 if (PyErr_Occurred()) SWIG_fail;
18922 }
18923 resultobj = SWIG_Py_Void();
18924 return resultobj;
18925 fail:
18926 return NULL;
18927 }
18928
18929
18930 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18931 PyObject *resultobj = 0;
18932 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18933 long result;
18934 void *argp1 = 0 ;
18935 int res1 = 0 ;
18936 PyObject *swig_obj[1] ;
18937
18938 if (!args) SWIG_fail;
18939 swig_obj[0] = args;
18940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18941 if (!SWIG_IsOK(res1)) {
18942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18943 }
18944 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18945 {
18946 PyThreadState* __tstate = wxPyBeginAllowThreads();
18947 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
18948 wxPyEndAllowThreads(__tstate);
18949 if (PyErr_Occurred()) SWIG_fail;
18950 }
18951 resultobj = SWIG_From_long(static_cast< long >(result));
18952 return resultobj;
18953 fail:
18954 return NULL;
18955 }
18956
18957
18958 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18959 PyObject *resultobj = 0;
18960 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18961 int arg2 ;
18962 void *argp1 = 0 ;
18963 int res1 = 0 ;
18964 int val2 ;
18965 int ecode2 = 0 ;
18966 PyObject * obj0 = 0 ;
18967 PyObject * obj1 = 0 ;
18968 char * kwnames[] = {
18969 (char *) "self",(char *) "i", NULL
18970 };
18971
18972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
18973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18974 if (!SWIG_IsOK(res1)) {
18975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18976 }
18977 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18978 ecode2 = SWIG_AsVal_int(obj1, &val2);
18979 if (!SWIG_IsOK(ecode2)) {
18980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
18981 }
18982 arg2 = static_cast< int >(val2);
18983 {
18984 PyThreadState* __tstate = wxPyBeginAllowThreads();
18985 (arg1)->SetInt(arg2);
18986 wxPyEndAllowThreads(__tstate);
18987 if (PyErr_Occurred()) SWIG_fail;
18988 }
18989 resultobj = SWIG_Py_Void();
18990 return resultobj;
18991 fail:
18992 return NULL;
18993 }
18994
18995
18996 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18997 PyObject *resultobj = 0;
18998 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18999 long result;
19000 void *argp1 = 0 ;
19001 int res1 = 0 ;
19002 PyObject *swig_obj[1] ;
19003
19004 if (!args) SWIG_fail;
19005 swig_obj[0] = args;
19006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19007 if (!SWIG_IsOK(res1)) {
19008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19009 }
19010 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19011 {
19012 PyThreadState* __tstate = wxPyBeginAllowThreads();
19013 result = (long)((wxCommandEvent const *)arg1)->GetInt();
19014 wxPyEndAllowThreads(__tstate);
19015 if (PyErr_Occurred()) SWIG_fail;
19016 }
19017 resultobj = SWIG_From_long(static_cast< long >(result));
19018 return resultobj;
19019 fail:
19020 return NULL;
19021 }
19022
19023
19024 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19025 PyObject *resultobj = 0;
19026 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19027 PyObject *result = 0 ;
19028 void *argp1 = 0 ;
19029 int res1 = 0 ;
19030 PyObject *swig_obj[1] ;
19031
19032 if (!args) SWIG_fail;
19033 swig_obj[0] = args;
19034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19035 if (!SWIG_IsOK(res1)) {
19036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19037 }
19038 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19039 {
19040 PyThreadState* __tstate = wxPyBeginAllowThreads();
19041 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19042 wxPyEndAllowThreads(__tstate);
19043 if (PyErr_Occurred()) SWIG_fail;
19044 }
19045 resultobj = result;
19046 return resultobj;
19047 fail:
19048 return NULL;
19049 }
19050
19051
19052 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19053 PyObject *resultobj = 0;
19054 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19055 PyObject *arg2 = (PyObject *) 0 ;
19056 void *argp1 = 0 ;
19057 int res1 = 0 ;
19058 PyObject * obj0 = 0 ;
19059 PyObject * obj1 = 0 ;
19060 char * kwnames[] = {
19061 (char *) "self",(char *) "clientData", NULL
19062 };
19063
19064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19066 if (!SWIG_IsOK(res1)) {
19067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19068 }
19069 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19070 arg2 = obj1;
19071 {
19072 PyThreadState* __tstate = wxPyBeginAllowThreads();
19073 wxCommandEvent_SetClientData(arg1,arg2);
19074 wxPyEndAllowThreads(__tstate);
19075 if (PyErr_Occurred()) SWIG_fail;
19076 }
19077 resultobj = SWIG_Py_Void();
19078 return resultobj;
19079 fail:
19080 return NULL;
19081 }
19082
19083
19084 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19085 PyObject *resultobj = 0;
19086 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19087 wxEvent *result = 0 ;
19088 void *argp1 = 0 ;
19089 int res1 = 0 ;
19090 PyObject *swig_obj[1] ;
19091
19092 if (!args) SWIG_fail;
19093 swig_obj[0] = args;
19094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19095 if (!SWIG_IsOK(res1)) {
19096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19097 }
19098 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19099 {
19100 PyThreadState* __tstate = wxPyBeginAllowThreads();
19101 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19102 wxPyEndAllowThreads(__tstate);
19103 if (PyErr_Occurred()) SWIG_fail;
19104 }
19105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19106 return resultobj;
19107 fail:
19108 return NULL;
19109 }
19110
19111
19112 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19113 PyObject *obj;
19114 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19115 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19116 return SWIG_Py_Void();
19117 }
19118
19119 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19120 return SWIG_Python_InitShadowInstance(args);
19121 }
19122
19123 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19124 PyObject *resultobj = 0;
19125 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19126 int arg2 = (int) 0 ;
19127 wxNotifyEvent *result = 0 ;
19128 int val1 ;
19129 int ecode1 = 0 ;
19130 int val2 ;
19131 int ecode2 = 0 ;
19132 PyObject * obj0 = 0 ;
19133 PyObject * obj1 = 0 ;
19134 char * kwnames[] = {
19135 (char *) "commandType",(char *) "winid", NULL
19136 };
19137
19138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19139 if (obj0) {
19140 ecode1 = SWIG_AsVal_int(obj0, &val1);
19141 if (!SWIG_IsOK(ecode1)) {
19142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19143 }
19144 arg1 = static_cast< wxEventType >(val1);
19145 }
19146 if (obj1) {
19147 ecode2 = SWIG_AsVal_int(obj1, &val2);
19148 if (!SWIG_IsOK(ecode2)) {
19149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19150 }
19151 arg2 = static_cast< int >(val2);
19152 }
19153 {
19154 PyThreadState* __tstate = wxPyBeginAllowThreads();
19155 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19156 wxPyEndAllowThreads(__tstate);
19157 if (PyErr_Occurred()) SWIG_fail;
19158 }
19159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19160 return resultobj;
19161 fail:
19162 return NULL;
19163 }
19164
19165
19166 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19167 PyObject *resultobj = 0;
19168 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19169 void *argp1 = 0 ;
19170 int res1 = 0 ;
19171 PyObject *swig_obj[1] ;
19172
19173 if (!args) SWIG_fail;
19174 swig_obj[0] = args;
19175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19176 if (!SWIG_IsOK(res1)) {
19177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19178 }
19179 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19180 {
19181 PyThreadState* __tstate = wxPyBeginAllowThreads();
19182 (arg1)->Veto();
19183 wxPyEndAllowThreads(__tstate);
19184 if (PyErr_Occurred()) SWIG_fail;
19185 }
19186 resultobj = SWIG_Py_Void();
19187 return resultobj;
19188 fail:
19189 return NULL;
19190 }
19191
19192
19193 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19194 PyObject *resultobj = 0;
19195 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19196 void *argp1 = 0 ;
19197 int res1 = 0 ;
19198 PyObject *swig_obj[1] ;
19199
19200 if (!args) SWIG_fail;
19201 swig_obj[0] = args;
19202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19203 if (!SWIG_IsOK(res1)) {
19204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19205 }
19206 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19207 {
19208 PyThreadState* __tstate = wxPyBeginAllowThreads();
19209 (arg1)->Allow();
19210 wxPyEndAllowThreads(__tstate);
19211 if (PyErr_Occurred()) SWIG_fail;
19212 }
19213 resultobj = SWIG_Py_Void();
19214 return resultobj;
19215 fail:
19216 return NULL;
19217 }
19218
19219
19220 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19221 PyObject *resultobj = 0;
19222 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19223 bool result;
19224 void *argp1 = 0 ;
19225 int res1 = 0 ;
19226 PyObject *swig_obj[1] ;
19227
19228 if (!args) SWIG_fail;
19229 swig_obj[0] = args;
19230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19231 if (!SWIG_IsOK(res1)) {
19232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19233 }
19234 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19235 {
19236 PyThreadState* __tstate = wxPyBeginAllowThreads();
19237 result = (bool)(arg1)->IsAllowed();
19238 wxPyEndAllowThreads(__tstate);
19239 if (PyErr_Occurred()) SWIG_fail;
19240 }
19241 {
19242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19243 }
19244 return resultobj;
19245 fail:
19246 return NULL;
19247 }
19248
19249
19250 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19251 PyObject *obj;
19252 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19253 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19254 return SWIG_Py_Void();
19255 }
19256
19257 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19258 return SWIG_Python_InitShadowInstance(args);
19259 }
19260
19261 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19262 PyObject *resultobj = 0;
19263 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19264 int arg2 = (int) 0 ;
19265 int arg3 = (int) 0 ;
19266 int arg4 = (int) 0 ;
19267 wxScrollEvent *result = 0 ;
19268 int val1 ;
19269 int ecode1 = 0 ;
19270 int val2 ;
19271 int ecode2 = 0 ;
19272 int val3 ;
19273 int ecode3 = 0 ;
19274 int val4 ;
19275 int ecode4 = 0 ;
19276 PyObject * obj0 = 0 ;
19277 PyObject * obj1 = 0 ;
19278 PyObject * obj2 = 0 ;
19279 PyObject * obj3 = 0 ;
19280 char * kwnames[] = {
19281 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19282 };
19283
19284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19285 if (obj0) {
19286 ecode1 = SWIG_AsVal_int(obj0, &val1);
19287 if (!SWIG_IsOK(ecode1)) {
19288 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19289 }
19290 arg1 = static_cast< wxEventType >(val1);
19291 }
19292 if (obj1) {
19293 ecode2 = SWIG_AsVal_int(obj1, &val2);
19294 if (!SWIG_IsOK(ecode2)) {
19295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19296 }
19297 arg2 = static_cast< int >(val2);
19298 }
19299 if (obj2) {
19300 ecode3 = SWIG_AsVal_int(obj2, &val3);
19301 if (!SWIG_IsOK(ecode3)) {
19302 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19303 }
19304 arg3 = static_cast< int >(val3);
19305 }
19306 if (obj3) {
19307 ecode4 = SWIG_AsVal_int(obj3, &val4);
19308 if (!SWIG_IsOK(ecode4)) {
19309 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19310 }
19311 arg4 = static_cast< int >(val4);
19312 }
19313 {
19314 PyThreadState* __tstate = wxPyBeginAllowThreads();
19315 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19316 wxPyEndAllowThreads(__tstate);
19317 if (PyErr_Occurred()) SWIG_fail;
19318 }
19319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19320 return resultobj;
19321 fail:
19322 return NULL;
19323 }
19324
19325
19326 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19327 PyObject *resultobj = 0;
19328 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19329 int result;
19330 void *argp1 = 0 ;
19331 int res1 = 0 ;
19332 PyObject *swig_obj[1] ;
19333
19334 if (!args) SWIG_fail;
19335 swig_obj[0] = args;
19336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19337 if (!SWIG_IsOK(res1)) {
19338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19339 }
19340 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19341 {
19342 PyThreadState* __tstate = wxPyBeginAllowThreads();
19343 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19344 wxPyEndAllowThreads(__tstate);
19345 if (PyErr_Occurred()) SWIG_fail;
19346 }
19347 resultobj = SWIG_From_int(static_cast< int >(result));
19348 return resultobj;
19349 fail:
19350 return NULL;
19351 }
19352
19353
19354 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19355 PyObject *resultobj = 0;
19356 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19357 int result;
19358 void *argp1 = 0 ;
19359 int res1 = 0 ;
19360 PyObject *swig_obj[1] ;
19361
19362 if (!args) SWIG_fail;
19363 swig_obj[0] = args;
19364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19365 if (!SWIG_IsOK(res1)) {
19366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19367 }
19368 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19369 {
19370 PyThreadState* __tstate = wxPyBeginAllowThreads();
19371 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19372 wxPyEndAllowThreads(__tstate);
19373 if (PyErr_Occurred()) SWIG_fail;
19374 }
19375 resultobj = SWIG_From_int(static_cast< int >(result));
19376 return resultobj;
19377 fail:
19378 return NULL;
19379 }
19380
19381
19382 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19383 PyObject *resultobj = 0;
19384 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19385 int arg2 ;
19386 void *argp1 = 0 ;
19387 int res1 = 0 ;
19388 int val2 ;
19389 int ecode2 = 0 ;
19390 PyObject * obj0 = 0 ;
19391 PyObject * obj1 = 0 ;
19392 char * kwnames[] = {
19393 (char *) "self",(char *) "orient", NULL
19394 };
19395
19396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19398 if (!SWIG_IsOK(res1)) {
19399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19400 }
19401 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19402 ecode2 = SWIG_AsVal_int(obj1, &val2);
19403 if (!SWIG_IsOK(ecode2)) {
19404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19405 }
19406 arg2 = static_cast< int >(val2);
19407 {
19408 PyThreadState* __tstate = wxPyBeginAllowThreads();
19409 (arg1)->SetOrientation(arg2);
19410 wxPyEndAllowThreads(__tstate);
19411 if (PyErr_Occurred()) SWIG_fail;
19412 }
19413 resultobj = SWIG_Py_Void();
19414 return resultobj;
19415 fail:
19416 return NULL;
19417 }
19418
19419
19420 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19421 PyObject *resultobj = 0;
19422 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19423 int arg2 ;
19424 void *argp1 = 0 ;
19425 int res1 = 0 ;
19426 int val2 ;
19427 int ecode2 = 0 ;
19428 PyObject * obj0 = 0 ;
19429 PyObject * obj1 = 0 ;
19430 char * kwnames[] = {
19431 (char *) "self",(char *) "pos", NULL
19432 };
19433
19434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19436 if (!SWIG_IsOK(res1)) {
19437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19438 }
19439 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19440 ecode2 = SWIG_AsVal_int(obj1, &val2);
19441 if (!SWIG_IsOK(ecode2)) {
19442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19443 }
19444 arg2 = static_cast< int >(val2);
19445 {
19446 PyThreadState* __tstate = wxPyBeginAllowThreads();
19447 (arg1)->SetPosition(arg2);
19448 wxPyEndAllowThreads(__tstate);
19449 if (PyErr_Occurred()) SWIG_fail;
19450 }
19451 resultobj = SWIG_Py_Void();
19452 return resultobj;
19453 fail:
19454 return NULL;
19455 }
19456
19457
19458 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19459 PyObject *obj;
19460 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19461 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19462 return SWIG_Py_Void();
19463 }
19464
19465 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19466 return SWIG_Python_InitShadowInstance(args);
19467 }
19468
19469 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19470 PyObject *resultobj = 0;
19471 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19472 int arg2 = (int) 0 ;
19473 int arg3 = (int) 0 ;
19474 wxScrollWinEvent *result = 0 ;
19475 int val1 ;
19476 int ecode1 = 0 ;
19477 int val2 ;
19478 int ecode2 = 0 ;
19479 int val3 ;
19480 int ecode3 = 0 ;
19481 PyObject * obj0 = 0 ;
19482 PyObject * obj1 = 0 ;
19483 PyObject * obj2 = 0 ;
19484 char * kwnames[] = {
19485 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19486 };
19487
19488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19489 if (obj0) {
19490 ecode1 = SWIG_AsVal_int(obj0, &val1);
19491 if (!SWIG_IsOK(ecode1)) {
19492 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19493 }
19494 arg1 = static_cast< wxEventType >(val1);
19495 }
19496 if (obj1) {
19497 ecode2 = SWIG_AsVal_int(obj1, &val2);
19498 if (!SWIG_IsOK(ecode2)) {
19499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19500 }
19501 arg2 = static_cast< int >(val2);
19502 }
19503 if (obj2) {
19504 ecode3 = SWIG_AsVal_int(obj2, &val3);
19505 if (!SWIG_IsOK(ecode3)) {
19506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19507 }
19508 arg3 = static_cast< int >(val3);
19509 }
19510 {
19511 PyThreadState* __tstate = wxPyBeginAllowThreads();
19512 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19513 wxPyEndAllowThreads(__tstate);
19514 if (PyErr_Occurred()) SWIG_fail;
19515 }
19516 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19517 return resultobj;
19518 fail:
19519 return NULL;
19520 }
19521
19522
19523 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19524 PyObject *resultobj = 0;
19525 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19526 int result;
19527 void *argp1 = 0 ;
19528 int res1 = 0 ;
19529 PyObject *swig_obj[1] ;
19530
19531 if (!args) SWIG_fail;
19532 swig_obj[0] = args;
19533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19534 if (!SWIG_IsOK(res1)) {
19535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19536 }
19537 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19538 {
19539 PyThreadState* __tstate = wxPyBeginAllowThreads();
19540 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19541 wxPyEndAllowThreads(__tstate);
19542 if (PyErr_Occurred()) SWIG_fail;
19543 }
19544 resultobj = SWIG_From_int(static_cast< int >(result));
19545 return resultobj;
19546 fail:
19547 return NULL;
19548 }
19549
19550
19551 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19552 PyObject *resultobj = 0;
19553 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19554 int result;
19555 void *argp1 = 0 ;
19556 int res1 = 0 ;
19557 PyObject *swig_obj[1] ;
19558
19559 if (!args) SWIG_fail;
19560 swig_obj[0] = args;
19561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19562 if (!SWIG_IsOK(res1)) {
19563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19564 }
19565 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19566 {
19567 PyThreadState* __tstate = wxPyBeginAllowThreads();
19568 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19569 wxPyEndAllowThreads(__tstate);
19570 if (PyErr_Occurred()) SWIG_fail;
19571 }
19572 resultobj = SWIG_From_int(static_cast< int >(result));
19573 return resultobj;
19574 fail:
19575 return NULL;
19576 }
19577
19578
19579 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19580 PyObject *resultobj = 0;
19581 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19582 int arg2 ;
19583 void *argp1 = 0 ;
19584 int res1 = 0 ;
19585 int val2 ;
19586 int ecode2 = 0 ;
19587 PyObject * obj0 = 0 ;
19588 PyObject * obj1 = 0 ;
19589 char * kwnames[] = {
19590 (char *) "self",(char *) "orient", NULL
19591 };
19592
19593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19595 if (!SWIG_IsOK(res1)) {
19596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19597 }
19598 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19599 ecode2 = SWIG_AsVal_int(obj1, &val2);
19600 if (!SWIG_IsOK(ecode2)) {
19601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19602 }
19603 arg2 = static_cast< int >(val2);
19604 {
19605 PyThreadState* __tstate = wxPyBeginAllowThreads();
19606 (arg1)->SetOrientation(arg2);
19607 wxPyEndAllowThreads(__tstate);
19608 if (PyErr_Occurred()) SWIG_fail;
19609 }
19610 resultobj = SWIG_Py_Void();
19611 return resultobj;
19612 fail:
19613 return NULL;
19614 }
19615
19616
19617 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19618 PyObject *resultobj = 0;
19619 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19620 int arg2 ;
19621 void *argp1 = 0 ;
19622 int res1 = 0 ;
19623 int val2 ;
19624 int ecode2 = 0 ;
19625 PyObject * obj0 = 0 ;
19626 PyObject * obj1 = 0 ;
19627 char * kwnames[] = {
19628 (char *) "self",(char *) "pos", NULL
19629 };
19630
19631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19633 if (!SWIG_IsOK(res1)) {
19634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19635 }
19636 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19637 ecode2 = SWIG_AsVal_int(obj1, &val2);
19638 if (!SWIG_IsOK(ecode2)) {
19639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19640 }
19641 arg2 = static_cast< int >(val2);
19642 {
19643 PyThreadState* __tstate = wxPyBeginAllowThreads();
19644 (arg1)->SetPosition(arg2);
19645 wxPyEndAllowThreads(__tstate);
19646 if (PyErr_Occurred()) SWIG_fail;
19647 }
19648 resultobj = SWIG_Py_Void();
19649 return resultobj;
19650 fail:
19651 return NULL;
19652 }
19653
19654
19655 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19656 PyObject *obj;
19657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19658 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19659 return SWIG_Py_Void();
19660 }
19661
19662 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19663 return SWIG_Python_InitShadowInstance(args);
19664 }
19665
19666 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19667 PyObject *resultobj = 0;
19668 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19669 wxMouseEvent *result = 0 ;
19670 int val1 ;
19671 int ecode1 = 0 ;
19672 PyObject * obj0 = 0 ;
19673 char * kwnames[] = {
19674 (char *) "mouseType", NULL
19675 };
19676
19677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19678 if (obj0) {
19679 ecode1 = SWIG_AsVal_int(obj0, &val1);
19680 if (!SWIG_IsOK(ecode1)) {
19681 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19682 }
19683 arg1 = static_cast< wxEventType >(val1);
19684 }
19685 {
19686 PyThreadState* __tstate = wxPyBeginAllowThreads();
19687 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19688 wxPyEndAllowThreads(__tstate);
19689 if (PyErr_Occurred()) SWIG_fail;
19690 }
19691 {
19692 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19693 }
19694 return resultobj;
19695 fail:
19696 return NULL;
19697 }
19698
19699
19700 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19701 PyObject *resultobj = 0;
19702 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19703 bool result;
19704 void *argp1 = 0 ;
19705 int res1 = 0 ;
19706 PyObject *swig_obj[1] ;
19707
19708 if (!args) SWIG_fail;
19709 swig_obj[0] = args;
19710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19711 if (!SWIG_IsOK(res1)) {
19712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19713 }
19714 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19715 {
19716 PyThreadState* __tstate = wxPyBeginAllowThreads();
19717 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19718 wxPyEndAllowThreads(__tstate);
19719 if (PyErr_Occurred()) SWIG_fail;
19720 }
19721 {
19722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19723 }
19724 return resultobj;
19725 fail:
19726 return NULL;
19727 }
19728
19729
19730 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19731 PyObject *resultobj = 0;
19732 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19733 int arg2 = (int) wxMOUSE_BTN_ANY ;
19734 bool result;
19735 void *argp1 = 0 ;
19736 int res1 = 0 ;
19737 int val2 ;
19738 int ecode2 = 0 ;
19739 PyObject * obj0 = 0 ;
19740 PyObject * obj1 = 0 ;
19741 char * kwnames[] = {
19742 (char *) "self",(char *) "but", NULL
19743 };
19744
19745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19747 if (!SWIG_IsOK(res1)) {
19748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19749 }
19750 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19751 if (obj1) {
19752 ecode2 = SWIG_AsVal_int(obj1, &val2);
19753 if (!SWIG_IsOK(ecode2)) {
19754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19755 }
19756 arg2 = static_cast< int >(val2);
19757 }
19758 {
19759 PyThreadState* __tstate = wxPyBeginAllowThreads();
19760 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19761 wxPyEndAllowThreads(__tstate);
19762 if (PyErr_Occurred()) SWIG_fail;
19763 }
19764 {
19765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19766 }
19767 return resultobj;
19768 fail:
19769 return NULL;
19770 }
19771
19772
19773 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19774 PyObject *resultobj = 0;
19775 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19776 int arg2 = (int) wxMOUSE_BTN_ANY ;
19777 bool result;
19778 void *argp1 = 0 ;
19779 int res1 = 0 ;
19780 int val2 ;
19781 int ecode2 = 0 ;
19782 PyObject * obj0 = 0 ;
19783 PyObject * obj1 = 0 ;
19784 char * kwnames[] = {
19785 (char *) "self",(char *) "but", NULL
19786 };
19787
19788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19790 if (!SWIG_IsOK(res1)) {
19791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19792 }
19793 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19794 if (obj1) {
19795 ecode2 = SWIG_AsVal_int(obj1, &val2);
19796 if (!SWIG_IsOK(ecode2)) {
19797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19798 }
19799 arg2 = static_cast< int >(val2);
19800 }
19801 {
19802 PyThreadState* __tstate = wxPyBeginAllowThreads();
19803 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19804 wxPyEndAllowThreads(__tstate);
19805 if (PyErr_Occurred()) SWIG_fail;
19806 }
19807 {
19808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19809 }
19810 return resultobj;
19811 fail:
19812 return NULL;
19813 }
19814
19815
19816 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19817 PyObject *resultobj = 0;
19818 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19819 int arg2 = (int) wxMOUSE_BTN_ANY ;
19820 bool result;
19821 void *argp1 = 0 ;
19822 int res1 = 0 ;
19823 int val2 ;
19824 int ecode2 = 0 ;
19825 PyObject * obj0 = 0 ;
19826 PyObject * obj1 = 0 ;
19827 char * kwnames[] = {
19828 (char *) "self",(char *) "but", NULL
19829 };
19830
19831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19833 if (!SWIG_IsOK(res1)) {
19834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19835 }
19836 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19837 if (obj1) {
19838 ecode2 = SWIG_AsVal_int(obj1, &val2);
19839 if (!SWIG_IsOK(ecode2)) {
19840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19841 }
19842 arg2 = static_cast< int >(val2);
19843 }
19844 {
19845 PyThreadState* __tstate = wxPyBeginAllowThreads();
19846 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19847 wxPyEndAllowThreads(__tstate);
19848 if (PyErr_Occurred()) SWIG_fail;
19849 }
19850 {
19851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19852 }
19853 return resultobj;
19854 fail:
19855 return NULL;
19856 }
19857
19858
19859 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19860 PyObject *resultobj = 0;
19861 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19862 int arg2 ;
19863 bool result;
19864 void *argp1 = 0 ;
19865 int res1 = 0 ;
19866 int val2 ;
19867 int ecode2 = 0 ;
19868 PyObject * obj0 = 0 ;
19869 PyObject * obj1 = 0 ;
19870 char * kwnames[] = {
19871 (char *) "self",(char *) "button", NULL
19872 };
19873
19874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19876 if (!SWIG_IsOK(res1)) {
19877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19878 }
19879 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19880 ecode2 = SWIG_AsVal_int(obj1, &val2);
19881 if (!SWIG_IsOK(ecode2)) {
19882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19883 }
19884 arg2 = static_cast< int >(val2);
19885 {
19886 PyThreadState* __tstate = wxPyBeginAllowThreads();
19887 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19888 wxPyEndAllowThreads(__tstate);
19889 if (PyErr_Occurred()) SWIG_fail;
19890 }
19891 {
19892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19893 }
19894 return resultobj;
19895 fail:
19896 return NULL;
19897 }
19898
19899
19900 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19901 PyObject *resultobj = 0;
19902 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19903 int arg2 ;
19904 bool result;
19905 void *argp1 = 0 ;
19906 int res1 = 0 ;
19907 int val2 ;
19908 int ecode2 = 0 ;
19909 PyObject * obj0 = 0 ;
19910 PyObject * obj1 = 0 ;
19911 char * kwnames[] = {
19912 (char *) "self",(char *) "but", NULL
19913 };
19914
19915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
19916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19917 if (!SWIG_IsOK(res1)) {
19918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19919 }
19920 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19921 ecode2 = SWIG_AsVal_int(obj1, &val2);
19922 if (!SWIG_IsOK(ecode2)) {
19923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
19924 }
19925 arg2 = static_cast< int >(val2);
19926 {
19927 PyThreadState* __tstate = wxPyBeginAllowThreads();
19928 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
19929 wxPyEndAllowThreads(__tstate);
19930 if (PyErr_Occurred()) SWIG_fail;
19931 }
19932 {
19933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19934 }
19935 return resultobj;
19936 fail:
19937 return NULL;
19938 }
19939
19940
19941 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19942 PyObject *resultobj = 0;
19943 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19944 int result;
19945 void *argp1 = 0 ;
19946 int res1 = 0 ;
19947 PyObject *swig_obj[1] ;
19948
19949 if (!args) SWIG_fail;
19950 swig_obj[0] = args;
19951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19952 if (!SWIG_IsOK(res1)) {
19953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19954 }
19955 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19956 {
19957 PyThreadState* __tstate = wxPyBeginAllowThreads();
19958 result = (int)((wxMouseEvent const *)arg1)->GetButton();
19959 wxPyEndAllowThreads(__tstate);
19960 if (PyErr_Occurred()) SWIG_fail;
19961 }
19962 resultobj = SWIG_From_int(static_cast< int >(result));
19963 return resultobj;
19964 fail:
19965 return NULL;
19966 }
19967
19968
19969 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19970 PyObject *resultobj = 0;
19971 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19972 bool result;
19973 void *argp1 = 0 ;
19974 int res1 = 0 ;
19975 PyObject *swig_obj[1] ;
19976
19977 if (!args) SWIG_fail;
19978 swig_obj[0] = args;
19979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19980 if (!SWIG_IsOK(res1)) {
19981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19982 }
19983 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19984 {
19985 PyThreadState* __tstate = wxPyBeginAllowThreads();
19986 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
19987 wxPyEndAllowThreads(__tstate);
19988 if (PyErr_Occurred()) SWIG_fail;
19989 }
19990 {
19991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19992 }
19993 return resultobj;
19994 fail:
19995 return NULL;
19996 }
19997
19998
19999 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20000 PyObject *resultobj = 0;
20001 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20002 bool result;
20003 void *argp1 = 0 ;
20004 int res1 = 0 ;
20005 PyObject *swig_obj[1] ;
20006
20007 if (!args) SWIG_fail;
20008 swig_obj[0] = args;
20009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20010 if (!SWIG_IsOK(res1)) {
20011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20012 }
20013 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20014 {
20015 PyThreadState* __tstate = wxPyBeginAllowThreads();
20016 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20017 wxPyEndAllowThreads(__tstate);
20018 if (PyErr_Occurred()) SWIG_fail;
20019 }
20020 {
20021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20022 }
20023 return resultobj;
20024 fail:
20025 return NULL;
20026 }
20027
20028
20029 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20030 PyObject *resultobj = 0;
20031 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20032 bool result;
20033 void *argp1 = 0 ;
20034 int res1 = 0 ;
20035 PyObject *swig_obj[1] ;
20036
20037 if (!args) SWIG_fail;
20038 swig_obj[0] = args;
20039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20040 if (!SWIG_IsOK(res1)) {
20041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20042 }
20043 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20044 {
20045 PyThreadState* __tstate = wxPyBeginAllowThreads();
20046 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20047 wxPyEndAllowThreads(__tstate);
20048 if (PyErr_Occurred()) SWIG_fail;
20049 }
20050 {
20051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20052 }
20053 return resultobj;
20054 fail:
20055 return NULL;
20056 }
20057
20058
20059 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20060 PyObject *resultobj = 0;
20061 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20062 bool result;
20063 void *argp1 = 0 ;
20064 int res1 = 0 ;
20065 PyObject *swig_obj[1] ;
20066
20067 if (!args) SWIG_fail;
20068 swig_obj[0] = args;
20069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20070 if (!SWIG_IsOK(res1)) {
20071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20072 }
20073 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20074 {
20075 PyThreadState* __tstate = wxPyBeginAllowThreads();
20076 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20077 wxPyEndAllowThreads(__tstate);
20078 if (PyErr_Occurred()) SWIG_fail;
20079 }
20080 {
20081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20082 }
20083 return resultobj;
20084 fail:
20085 return NULL;
20086 }
20087
20088
20089 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20090 PyObject *resultobj = 0;
20091 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20092 bool result;
20093 void *argp1 = 0 ;
20094 int res1 = 0 ;
20095 PyObject *swig_obj[1] ;
20096
20097 if (!args) SWIG_fail;
20098 swig_obj[0] = args;
20099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20100 if (!SWIG_IsOK(res1)) {
20101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20102 }
20103 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20104 {
20105 PyThreadState* __tstate = wxPyBeginAllowThreads();
20106 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20107 wxPyEndAllowThreads(__tstate);
20108 if (PyErr_Occurred()) SWIG_fail;
20109 }
20110 {
20111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20112 }
20113 return resultobj;
20114 fail:
20115 return NULL;
20116 }
20117
20118
20119 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20120 PyObject *resultobj = 0;
20121 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20122 bool result;
20123 void *argp1 = 0 ;
20124 int res1 = 0 ;
20125 PyObject *swig_obj[1] ;
20126
20127 if (!args) SWIG_fail;
20128 swig_obj[0] = args;
20129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20130 if (!SWIG_IsOK(res1)) {
20131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20132 }
20133 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20134 {
20135 PyThreadState* __tstate = wxPyBeginAllowThreads();
20136 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20137 wxPyEndAllowThreads(__tstate);
20138 if (PyErr_Occurred()) SWIG_fail;
20139 }
20140 {
20141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20142 }
20143 return resultobj;
20144 fail:
20145 return NULL;
20146 }
20147
20148
20149 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20150 PyObject *resultobj = 0;
20151 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20152 bool result;
20153 void *argp1 = 0 ;
20154 int res1 = 0 ;
20155 PyObject *swig_obj[1] ;
20156
20157 if (!args) SWIG_fail;
20158 swig_obj[0] = args;
20159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20160 if (!SWIG_IsOK(res1)) {
20161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20162 }
20163 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20164 {
20165 PyThreadState* __tstate = wxPyBeginAllowThreads();
20166 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20167 wxPyEndAllowThreads(__tstate);
20168 if (PyErr_Occurred()) SWIG_fail;
20169 }
20170 {
20171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20172 }
20173 return resultobj;
20174 fail:
20175 return NULL;
20176 }
20177
20178
20179 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20180 PyObject *resultobj = 0;
20181 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20182 bool result;
20183 void *argp1 = 0 ;
20184 int res1 = 0 ;
20185 PyObject *swig_obj[1] ;
20186
20187 if (!args) SWIG_fail;
20188 swig_obj[0] = args;
20189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20190 if (!SWIG_IsOK(res1)) {
20191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20192 }
20193 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20194 {
20195 PyThreadState* __tstate = wxPyBeginAllowThreads();
20196 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20197 wxPyEndAllowThreads(__tstate);
20198 if (PyErr_Occurred()) SWIG_fail;
20199 }
20200 {
20201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20202 }
20203 return resultobj;
20204 fail:
20205 return NULL;
20206 }
20207
20208
20209 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20210 PyObject *resultobj = 0;
20211 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20212 bool result;
20213 void *argp1 = 0 ;
20214 int res1 = 0 ;
20215 PyObject *swig_obj[1] ;
20216
20217 if (!args) SWIG_fail;
20218 swig_obj[0] = args;
20219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20220 if (!SWIG_IsOK(res1)) {
20221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20222 }
20223 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20224 {
20225 PyThreadState* __tstate = wxPyBeginAllowThreads();
20226 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20227 wxPyEndAllowThreads(__tstate);
20228 if (PyErr_Occurred()) SWIG_fail;
20229 }
20230 {
20231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20232 }
20233 return resultobj;
20234 fail:
20235 return NULL;
20236 }
20237
20238
20239 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20240 PyObject *resultobj = 0;
20241 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20242 bool result;
20243 void *argp1 = 0 ;
20244 int res1 = 0 ;
20245 PyObject *swig_obj[1] ;
20246
20247 if (!args) SWIG_fail;
20248 swig_obj[0] = args;
20249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20250 if (!SWIG_IsOK(res1)) {
20251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20252 }
20253 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20254 {
20255 PyThreadState* __tstate = wxPyBeginAllowThreads();
20256 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20257 wxPyEndAllowThreads(__tstate);
20258 if (PyErr_Occurred()) SWIG_fail;
20259 }
20260 {
20261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20262 }
20263 return resultobj;
20264 fail:
20265 return NULL;
20266 }
20267
20268
20269 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20270 PyObject *resultobj = 0;
20271 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20272 bool result;
20273 void *argp1 = 0 ;
20274 int res1 = 0 ;
20275 PyObject *swig_obj[1] ;
20276
20277 if (!args) SWIG_fail;
20278 swig_obj[0] = args;
20279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20280 if (!SWIG_IsOK(res1)) {
20281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20282 }
20283 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20284 {
20285 PyThreadState* __tstate = wxPyBeginAllowThreads();
20286 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20287 wxPyEndAllowThreads(__tstate);
20288 if (PyErr_Occurred()) SWIG_fail;
20289 }
20290 {
20291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20292 }
20293 return resultobj;
20294 fail:
20295 return NULL;
20296 }
20297
20298
20299 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20300 PyObject *resultobj = 0;
20301 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20302 bool result;
20303 void *argp1 = 0 ;
20304 int res1 = 0 ;
20305 PyObject *swig_obj[1] ;
20306
20307 if (!args) SWIG_fail;
20308 swig_obj[0] = args;
20309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20310 if (!SWIG_IsOK(res1)) {
20311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20312 }
20313 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20314 {
20315 PyThreadState* __tstate = wxPyBeginAllowThreads();
20316 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20317 wxPyEndAllowThreads(__tstate);
20318 if (PyErr_Occurred()) SWIG_fail;
20319 }
20320 {
20321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20322 }
20323 return resultobj;
20324 fail:
20325 return NULL;
20326 }
20327
20328
20329 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20330 PyObject *resultobj = 0;
20331 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20332 bool result;
20333 void *argp1 = 0 ;
20334 int res1 = 0 ;
20335 PyObject *swig_obj[1] ;
20336
20337 if (!args) SWIG_fail;
20338 swig_obj[0] = args;
20339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20340 if (!SWIG_IsOK(res1)) {
20341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20342 }
20343 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20344 {
20345 PyThreadState* __tstate = wxPyBeginAllowThreads();
20346 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20347 wxPyEndAllowThreads(__tstate);
20348 if (PyErr_Occurred()) SWIG_fail;
20349 }
20350 {
20351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20352 }
20353 return resultobj;
20354 fail:
20355 return NULL;
20356 }
20357
20358
20359 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20360 PyObject *resultobj = 0;
20361 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20362 bool result;
20363 void *argp1 = 0 ;
20364 int res1 = 0 ;
20365 PyObject *swig_obj[1] ;
20366
20367 if (!args) SWIG_fail;
20368 swig_obj[0] = args;
20369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20370 if (!SWIG_IsOK(res1)) {
20371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20372 }
20373 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20374 {
20375 PyThreadState* __tstate = wxPyBeginAllowThreads();
20376 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20377 wxPyEndAllowThreads(__tstate);
20378 if (PyErr_Occurred()) SWIG_fail;
20379 }
20380 {
20381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20382 }
20383 return resultobj;
20384 fail:
20385 return NULL;
20386 }
20387
20388
20389 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20390 PyObject *resultobj = 0;
20391 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20392 bool result;
20393 void *argp1 = 0 ;
20394 int res1 = 0 ;
20395 PyObject *swig_obj[1] ;
20396
20397 if (!args) SWIG_fail;
20398 swig_obj[0] = args;
20399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20400 if (!SWIG_IsOK(res1)) {
20401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20402 }
20403 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20404 {
20405 PyThreadState* __tstate = wxPyBeginAllowThreads();
20406 result = (bool)(arg1)->LeftIsDown();
20407 wxPyEndAllowThreads(__tstate);
20408 if (PyErr_Occurred()) SWIG_fail;
20409 }
20410 {
20411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20412 }
20413 return resultobj;
20414 fail:
20415 return NULL;
20416 }
20417
20418
20419 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20420 PyObject *resultobj = 0;
20421 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20422 bool result;
20423 void *argp1 = 0 ;
20424 int res1 = 0 ;
20425 PyObject *swig_obj[1] ;
20426
20427 if (!args) SWIG_fail;
20428 swig_obj[0] = args;
20429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20430 if (!SWIG_IsOK(res1)) {
20431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20432 }
20433 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20434 {
20435 PyThreadState* __tstate = wxPyBeginAllowThreads();
20436 result = (bool)(arg1)->MiddleIsDown();
20437 wxPyEndAllowThreads(__tstate);
20438 if (PyErr_Occurred()) SWIG_fail;
20439 }
20440 {
20441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20442 }
20443 return resultobj;
20444 fail:
20445 return NULL;
20446 }
20447
20448
20449 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20450 PyObject *resultobj = 0;
20451 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20452 bool result;
20453 void *argp1 = 0 ;
20454 int res1 = 0 ;
20455 PyObject *swig_obj[1] ;
20456
20457 if (!args) SWIG_fail;
20458 swig_obj[0] = args;
20459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20460 if (!SWIG_IsOK(res1)) {
20461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20462 }
20463 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20464 {
20465 PyThreadState* __tstate = wxPyBeginAllowThreads();
20466 result = (bool)(arg1)->RightIsDown();
20467 wxPyEndAllowThreads(__tstate);
20468 if (PyErr_Occurred()) SWIG_fail;
20469 }
20470 {
20471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20472 }
20473 return resultobj;
20474 fail:
20475 return NULL;
20476 }
20477
20478
20479 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20480 PyObject *resultobj = 0;
20481 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20482 bool result;
20483 void *argp1 = 0 ;
20484 int res1 = 0 ;
20485 PyObject *swig_obj[1] ;
20486
20487 if (!args) SWIG_fail;
20488 swig_obj[0] = args;
20489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20490 if (!SWIG_IsOK(res1)) {
20491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20492 }
20493 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20494 {
20495 PyThreadState* __tstate = wxPyBeginAllowThreads();
20496 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20497 wxPyEndAllowThreads(__tstate);
20498 if (PyErr_Occurred()) SWIG_fail;
20499 }
20500 {
20501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20502 }
20503 return resultobj;
20504 fail:
20505 return NULL;
20506 }
20507
20508
20509 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20510 PyObject *resultobj = 0;
20511 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20512 bool result;
20513 void *argp1 = 0 ;
20514 int res1 = 0 ;
20515 PyObject *swig_obj[1] ;
20516
20517 if (!args) SWIG_fail;
20518 swig_obj[0] = args;
20519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20520 if (!SWIG_IsOK(res1)) {
20521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20522 }
20523 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20524 {
20525 PyThreadState* __tstate = wxPyBeginAllowThreads();
20526 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20527 wxPyEndAllowThreads(__tstate);
20528 if (PyErr_Occurred()) SWIG_fail;
20529 }
20530 {
20531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20532 }
20533 return resultobj;
20534 fail:
20535 return NULL;
20536 }
20537
20538
20539 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20540 PyObject *resultobj = 0;
20541 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20542 bool result;
20543 void *argp1 = 0 ;
20544 int res1 = 0 ;
20545 PyObject *swig_obj[1] ;
20546
20547 if (!args) SWIG_fail;
20548 swig_obj[0] = args;
20549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20550 if (!SWIG_IsOK(res1)) {
20551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20552 }
20553 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20554 {
20555 PyThreadState* __tstate = wxPyBeginAllowThreads();
20556 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20557 wxPyEndAllowThreads(__tstate);
20558 if (PyErr_Occurred()) SWIG_fail;
20559 }
20560 {
20561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20562 }
20563 return resultobj;
20564 fail:
20565 return NULL;
20566 }
20567
20568
20569 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20570 PyObject *resultobj = 0;
20571 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20572 bool result;
20573 void *argp1 = 0 ;
20574 int res1 = 0 ;
20575 PyObject *swig_obj[1] ;
20576
20577 if (!args) SWIG_fail;
20578 swig_obj[0] = args;
20579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20580 if (!SWIG_IsOK(res1)) {
20581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20582 }
20583 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20584 {
20585 PyThreadState* __tstate = wxPyBeginAllowThreads();
20586 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20587 wxPyEndAllowThreads(__tstate);
20588 if (PyErr_Occurred()) SWIG_fail;
20589 }
20590 {
20591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20592 }
20593 return resultobj;
20594 fail:
20595 return NULL;
20596 }
20597
20598
20599 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20600 PyObject *resultobj = 0;
20601 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20602 wxPoint result;
20603 void *argp1 = 0 ;
20604 int res1 = 0 ;
20605 PyObject *swig_obj[1] ;
20606
20607 if (!args) SWIG_fail;
20608 swig_obj[0] = args;
20609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20610 if (!SWIG_IsOK(res1)) {
20611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20612 }
20613 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20614 {
20615 PyThreadState* __tstate = wxPyBeginAllowThreads();
20616 result = (arg1)->GetPosition();
20617 wxPyEndAllowThreads(__tstate);
20618 if (PyErr_Occurred()) SWIG_fail;
20619 }
20620 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20621 return resultobj;
20622 fail:
20623 return NULL;
20624 }
20625
20626
20627 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20628 PyObject *resultobj = 0;
20629 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20630 long *arg2 = (long *) 0 ;
20631 long *arg3 = (long *) 0 ;
20632 void *argp1 = 0 ;
20633 int res1 = 0 ;
20634 long temp2 ;
20635 int res2 = SWIG_TMPOBJ ;
20636 long temp3 ;
20637 int res3 = SWIG_TMPOBJ ;
20638 PyObject *swig_obj[1] ;
20639
20640 arg2 = &temp2;
20641 arg3 = &temp3;
20642 if (!args) SWIG_fail;
20643 swig_obj[0] = args;
20644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20645 if (!SWIG_IsOK(res1)) {
20646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20647 }
20648 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20649 {
20650 PyThreadState* __tstate = wxPyBeginAllowThreads();
20651 (arg1)->GetPosition(arg2,arg3);
20652 wxPyEndAllowThreads(__tstate);
20653 if (PyErr_Occurred()) SWIG_fail;
20654 }
20655 resultobj = SWIG_Py_Void();
20656 if (SWIG_IsTmpObj(res2)) {
20657 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20658 } else {
20659 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20660 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20661 }
20662 if (SWIG_IsTmpObj(res3)) {
20663 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20664 } else {
20665 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20666 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20667 }
20668 return resultobj;
20669 fail:
20670 return NULL;
20671 }
20672
20673
20674 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20675 PyObject *resultobj = 0;
20676 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20677 wxDC *arg2 = 0 ;
20678 wxPoint result;
20679 void *argp1 = 0 ;
20680 int res1 = 0 ;
20681 void *argp2 = 0 ;
20682 int res2 = 0 ;
20683 PyObject * obj0 = 0 ;
20684 PyObject * obj1 = 0 ;
20685 char * kwnames[] = {
20686 (char *) "self",(char *) "dc", NULL
20687 };
20688
20689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20691 if (!SWIG_IsOK(res1)) {
20692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20693 }
20694 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20695 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20696 if (!SWIG_IsOK(res2)) {
20697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20698 }
20699 if (!argp2) {
20700 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20701 }
20702 arg2 = reinterpret_cast< wxDC * >(argp2);
20703 {
20704 PyThreadState* __tstate = wxPyBeginAllowThreads();
20705 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20706 wxPyEndAllowThreads(__tstate);
20707 if (PyErr_Occurred()) SWIG_fail;
20708 }
20709 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20710 return resultobj;
20711 fail:
20712 return NULL;
20713 }
20714
20715
20716 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20717 PyObject *resultobj = 0;
20718 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20719 int result;
20720 void *argp1 = 0 ;
20721 int res1 = 0 ;
20722 PyObject *swig_obj[1] ;
20723
20724 if (!args) SWIG_fail;
20725 swig_obj[0] = args;
20726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20727 if (!SWIG_IsOK(res1)) {
20728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20729 }
20730 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20731 {
20732 PyThreadState* __tstate = wxPyBeginAllowThreads();
20733 result = (int)((wxMouseEvent const *)arg1)->GetX();
20734 wxPyEndAllowThreads(__tstate);
20735 if (PyErr_Occurred()) SWIG_fail;
20736 }
20737 resultobj = SWIG_From_int(static_cast< int >(result));
20738 return resultobj;
20739 fail:
20740 return NULL;
20741 }
20742
20743
20744 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20745 PyObject *resultobj = 0;
20746 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20747 int result;
20748 void *argp1 = 0 ;
20749 int res1 = 0 ;
20750 PyObject *swig_obj[1] ;
20751
20752 if (!args) SWIG_fail;
20753 swig_obj[0] = args;
20754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20755 if (!SWIG_IsOK(res1)) {
20756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20757 }
20758 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20759 {
20760 PyThreadState* __tstate = wxPyBeginAllowThreads();
20761 result = (int)((wxMouseEvent const *)arg1)->GetY();
20762 wxPyEndAllowThreads(__tstate);
20763 if (PyErr_Occurred()) SWIG_fail;
20764 }
20765 resultobj = SWIG_From_int(static_cast< int >(result));
20766 return resultobj;
20767 fail:
20768 return NULL;
20769 }
20770
20771
20772 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20773 PyObject *resultobj = 0;
20774 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20775 int result;
20776 void *argp1 = 0 ;
20777 int res1 = 0 ;
20778 PyObject *swig_obj[1] ;
20779
20780 if (!args) SWIG_fail;
20781 swig_obj[0] = args;
20782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20783 if (!SWIG_IsOK(res1)) {
20784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20785 }
20786 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20787 {
20788 PyThreadState* __tstate = wxPyBeginAllowThreads();
20789 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20790 wxPyEndAllowThreads(__tstate);
20791 if (PyErr_Occurred()) SWIG_fail;
20792 }
20793 resultobj = SWIG_From_int(static_cast< int >(result));
20794 return resultobj;
20795 fail:
20796 return NULL;
20797 }
20798
20799
20800 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20801 PyObject *resultobj = 0;
20802 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20803 int result;
20804 void *argp1 = 0 ;
20805 int res1 = 0 ;
20806 PyObject *swig_obj[1] ;
20807
20808 if (!args) SWIG_fail;
20809 swig_obj[0] = args;
20810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20811 if (!SWIG_IsOK(res1)) {
20812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20813 }
20814 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20815 {
20816 PyThreadState* __tstate = wxPyBeginAllowThreads();
20817 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20818 wxPyEndAllowThreads(__tstate);
20819 if (PyErr_Occurred()) SWIG_fail;
20820 }
20821 resultobj = SWIG_From_int(static_cast< int >(result));
20822 return resultobj;
20823 fail:
20824 return NULL;
20825 }
20826
20827
20828 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20829 PyObject *resultobj = 0;
20830 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20831 int result;
20832 void *argp1 = 0 ;
20833 int res1 = 0 ;
20834 PyObject *swig_obj[1] ;
20835
20836 if (!args) SWIG_fail;
20837 swig_obj[0] = args;
20838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20839 if (!SWIG_IsOK(res1)) {
20840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20841 }
20842 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20843 {
20844 PyThreadState* __tstate = wxPyBeginAllowThreads();
20845 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20846 wxPyEndAllowThreads(__tstate);
20847 if (PyErr_Occurred()) SWIG_fail;
20848 }
20849 resultobj = SWIG_From_int(static_cast< int >(result));
20850 return resultobj;
20851 fail:
20852 return NULL;
20853 }
20854
20855
20856 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20857 PyObject *resultobj = 0;
20858 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20859 bool result;
20860 void *argp1 = 0 ;
20861 int res1 = 0 ;
20862 PyObject *swig_obj[1] ;
20863
20864 if (!args) SWIG_fail;
20865 swig_obj[0] = args;
20866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20867 if (!SWIG_IsOK(res1)) {
20868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20869 }
20870 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20871 {
20872 PyThreadState* __tstate = wxPyBeginAllowThreads();
20873 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20874 wxPyEndAllowThreads(__tstate);
20875 if (PyErr_Occurred()) SWIG_fail;
20876 }
20877 {
20878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20879 }
20880 return resultobj;
20881 fail:
20882 return NULL;
20883 }
20884
20885
20886 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20887 PyObject *resultobj = 0;
20888 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20889 int arg2 ;
20890 void *argp1 = 0 ;
20891 int res1 = 0 ;
20892 int val2 ;
20893 int ecode2 = 0 ;
20894 PyObject *swig_obj[2] ;
20895
20896 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20898 if (!SWIG_IsOK(res1)) {
20899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20900 }
20901 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20902 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20903 if (!SWIG_IsOK(ecode2)) {
20904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20905 }
20906 arg2 = static_cast< int >(val2);
20907 if (arg1) (arg1)->m_x = arg2;
20908
20909 resultobj = SWIG_Py_Void();
20910 return resultobj;
20911 fail:
20912 return NULL;
20913 }
20914
20915
20916 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20917 PyObject *resultobj = 0;
20918 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20919 int result;
20920 void *argp1 = 0 ;
20921 int res1 = 0 ;
20922 PyObject *swig_obj[1] ;
20923
20924 if (!args) SWIG_fail;
20925 swig_obj[0] = args;
20926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20927 if (!SWIG_IsOK(res1)) {
20928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20929 }
20930 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20931 result = (int) ((arg1)->m_x);
20932 resultobj = SWIG_From_int(static_cast< int >(result));
20933 return resultobj;
20934 fail:
20935 return NULL;
20936 }
20937
20938
20939 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20940 PyObject *resultobj = 0;
20941 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20942 int arg2 ;
20943 void *argp1 = 0 ;
20944 int res1 = 0 ;
20945 int val2 ;
20946 int ecode2 = 0 ;
20947 PyObject *swig_obj[2] ;
20948
20949 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
20950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20951 if (!SWIG_IsOK(res1)) {
20952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20953 }
20954 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20955 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20956 if (!SWIG_IsOK(ecode2)) {
20957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
20958 }
20959 arg2 = static_cast< int >(val2);
20960 if (arg1) (arg1)->m_y = arg2;
20961
20962 resultobj = SWIG_Py_Void();
20963 return resultobj;
20964 fail:
20965 return NULL;
20966 }
20967
20968
20969 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20970 PyObject *resultobj = 0;
20971 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20972 int result;
20973 void *argp1 = 0 ;
20974 int res1 = 0 ;
20975 PyObject *swig_obj[1] ;
20976
20977 if (!args) SWIG_fail;
20978 swig_obj[0] = args;
20979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20980 if (!SWIG_IsOK(res1)) {
20981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20982 }
20983 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20984 result = (int) ((arg1)->m_y);
20985 resultobj = SWIG_From_int(static_cast< int >(result));
20986 return resultobj;
20987 fail:
20988 return NULL;
20989 }
20990
20991
20992 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20993 PyObject *resultobj = 0;
20994 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20995 bool arg2 ;
20996 void *argp1 = 0 ;
20997 int res1 = 0 ;
20998 bool val2 ;
20999 int ecode2 = 0 ;
21000 PyObject *swig_obj[2] ;
21001
21002 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21004 if (!SWIG_IsOK(res1)) {
21005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21006 }
21007 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21008 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21009 if (!SWIG_IsOK(ecode2)) {
21010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21011 }
21012 arg2 = static_cast< bool >(val2);
21013 if (arg1) (arg1)->m_leftDown = arg2;
21014
21015 resultobj = SWIG_Py_Void();
21016 return resultobj;
21017 fail:
21018 return NULL;
21019 }
21020
21021
21022 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21023 PyObject *resultobj = 0;
21024 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21025 bool result;
21026 void *argp1 = 0 ;
21027 int res1 = 0 ;
21028 PyObject *swig_obj[1] ;
21029
21030 if (!args) SWIG_fail;
21031 swig_obj[0] = args;
21032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21033 if (!SWIG_IsOK(res1)) {
21034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21035 }
21036 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21037 result = (bool) ((arg1)->m_leftDown);
21038 {
21039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21040 }
21041 return resultobj;
21042 fail:
21043 return NULL;
21044 }
21045
21046
21047 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21048 PyObject *resultobj = 0;
21049 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21050 bool arg2 ;
21051 void *argp1 = 0 ;
21052 int res1 = 0 ;
21053 bool val2 ;
21054 int ecode2 = 0 ;
21055 PyObject *swig_obj[2] ;
21056
21057 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21059 if (!SWIG_IsOK(res1)) {
21060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21061 }
21062 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21063 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21064 if (!SWIG_IsOK(ecode2)) {
21065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21066 }
21067 arg2 = static_cast< bool >(val2);
21068 if (arg1) (arg1)->m_middleDown = arg2;
21069
21070 resultobj = SWIG_Py_Void();
21071 return resultobj;
21072 fail:
21073 return NULL;
21074 }
21075
21076
21077 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21078 PyObject *resultobj = 0;
21079 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21080 bool result;
21081 void *argp1 = 0 ;
21082 int res1 = 0 ;
21083 PyObject *swig_obj[1] ;
21084
21085 if (!args) SWIG_fail;
21086 swig_obj[0] = args;
21087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21088 if (!SWIG_IsOK(res1)) {
21089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21090 }
21091 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21092 result = (bool) ((arg1)->m_middleDown);
21093 {
21094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21095 }
21096 return resultobj;
21097 fail:
21098 return NULL;
21099 }
21100
21101
21102 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21103 PyObject *resultobj = 0;
21104 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21105 bool arg2 ;
21106 void *argp1 = 0 ;
21107 int res1 = 0 ;
21108 bool val2 ;
21109 int ecode2 = 0 ;
21110 PyObject *swig_obj[2] ;
21111
21112 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21114 if (!SWIG_IsOK(res1)) {
21115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21116 }
21117 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21118 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21119 if (!SWIG_IsOK(ecode2)) {
21120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21121 }
21122 arg2 = static_cast< bool >(val2);
21123 if (arg1) (arg1)->m_rightDown = arg2;
21124
21125 resultobj = SWIG_Py_Void();
21126 return resultobj;
21127 fail:
21128 return NULL;
21129 }
21130
21131
21132 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21133 PyObject *resultobj = 0;
21134 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21135 bool result;
21136 void *argp1 = 0 ;
21137 int res1 = 0 ;
21138 PyObject *swig_obj[1] ;
21139
21140 if (!args) SWIG_fail;
21141 swig_obj[0] = args;
21142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21143 if (!SWIG_IsOK(res1)) {
21144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21145 }
21146 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21147 result = (bool) ((arg1)->m_rightDown);
21148 {
21149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21150 }
21151 return resultobj;
21152 fail:
21153 return NULL;
21154 }
21155
21156
21157 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21158 PyObject *resultobj = 0;
21159 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21160 bool arg2 ;
21161 void *argp1 = 0 ;
21162 int res1 = 0 ;
21163 bool val2 ;
21164 int ecode2 = 0 ;
21165 PyObject *swig_obj[2] ;
21166
21167 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21169 if (!SWIG_IsOK(res1)) {
21170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21171 }
21172 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21173 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21174 if (!SWIG_IsOK(ecode2)) {
21175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21176 }
21177 arg2 = static_cast< bool >(val2);
21178 if (arg1) (arg1)->m_controlDown = arg2;
21179
21180 resultobj = SWIG_Py_Void();
21181 return resultobj;
21182 fail:
21183 return NULL;
21184 }
21185
21186
21187 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21188 PyObject *resultobj = 0;
21189 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21190 bool result;
21191 void *argp1 = 0 ;
21192 int res1 = 0 ;
21193 PyObject *swig_obj[1] ;
21194
21195 if (!args) SWIG_fail;
21196 swig_obj[0] = args;
21197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21198 if (!SWIG_IsOK(res1)) {
21199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21200 }
21201 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21202 result = (bool) ((arg1)->m_controlDown);
21203 {
21204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21205 }
21206 return resultobj;
21207 fail:
21208 return NULL;
21209 }
21210
21211
21212 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21213 PyObject *resultobj = 0;
21214 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21215 bool arg2 ;
21216 void *argp1 = 0 ;
21217 int res1 = 0 ;
21218 bool val2 ;
21219 int ecode2 = 0 ;
21220 PyObject *swig_obj[2] ;
21221
21222 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21224 if (!SWIG_IsOK(res1)) {
21225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21226 }
21227 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21228 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21229 if (!SWIG_IsOK(ecode2)) {
21230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21231 }
21232 arg2 = static_cast< bool >(val2);
21233 if (arg1) (arg1)->m_shiftDown = arg2;
21234
21235 resultobj = SWIG_Py_Void();
21236 return resultobj;
21237 fail:
21238 return NULL;
21239 }
21240
21241
21242 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21243 PyObject *resultobj = 0;
21244 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21245 bool result;
21246 void *argp1 = 0 ;
21247 int res1 = 0 ;
21248 PyObject *swig_obj[1] ;
21249
21250 if (!args) SWIG_fail;
21251 swig_obj[0] = args;
21252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21253 if (!SWIG_IsOK(res1)) {
21254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21255 }
21256 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21257 result = (bool) ((arg1)->m_shiftDown);
21258 {
21259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21260 }
21261 return resultobj;
21262 fail:
21263 return NULL;
21264 }
21265
21266
21267 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21268 PyObject *resultobj = 0;
21269 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21270 bool arg2 ;
21271 void *argp1 = 0 ;
21272 int res1 = 0 ;
21273 bool val2 ;
21274 int ecode2 = 0 ;
21275 PyObject *swig_obj[2] ;
21276
21277 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21279 if (!SWIG_IsOK(res1)) {
21280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21281 }
21282 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21283 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21284 if (!SWIG_IsOK(ecode2)) {
21285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21286 }
21287 arg2 = static_cast< bool >(val2);
21288 if (arg1) (arg1)->m_altDown = arg2;
21289
21290 resultobj = SWIG_Py_Void();
21291 return resultobj;
21292 fail:
21293 return NULL;
21294 }
21295
21296
21297 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21298 PyObject *resultobj = 0;
21299 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21300 bool result;
21301 void *argp1 = 0 ;
21302 int res1 = 0 ;
21303 PyObject *swig_obj[1] ;
21304
21305 if (!args) SWIG_fail;
21306 swig_obj[0] = args;
21307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21308 if (!SWIG_IsOK(res1)) {
21309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21310 }
21311 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21312 result = (bool) ((arg1)->m_altDown);
21313 {
21314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21315 }
21316 return resultobj;
21317 fail:
21318 return NULL;
21319 }
21320
21321
21322 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21323 PyObject *resultobj = 0;
21324 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21325 bool arg2 ;
21326 void *argp1 = 0 ;
21327 int res1 = 0 ;
21328 bool val2 ;
21329 int ecode2 = 0 ;
21330 PyObject *swig_obj[2] ;
21331
21332 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21334 if (!SWIG_IsOK(res1)) {
21335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21336 }
21337 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21338 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21339 if (!SWIG_IsOK(ecode2)) {
21340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21341 }
21342 arg2 = static_cast< bool >(val2);
21343 if (arg1) (arg1)->m_metaDown = arg2;
21344
21345 resultobj = SWIG_Py_Void();
21346 return resultobj;
21347 fail:
21348 return NULL;
21349 }
21350
21351
21352 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21353 PyObject *resultobj = 0;
21354 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21355 bool result;
21356 void *argp1 = 0 ;
21357 int res1 = 0 ;
21358 PyObject *swig_obj[1] ;
21359
21360 if (!args) SWIG_fail;
21361 swig_obj[0] = args;
21362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21363 if (!SWIG_IsOK(res1)) {
21364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21365 }
21366 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21367 result = (bool) ((arg1)->m_metaDown);
21368 {
21369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21370 }
21371 return resultobj;
21372 fail:
21373 return NULL;
21374 }
21375
21376
21377 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21378 PyObject *resultobj = 0;
21379 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21380 int arg2 ;
21381 void *argp1 = 0 ;
21382 int res1 = 0 ;
21383 int val2 ;
21384 int ecode2 = 0 ;
21385 PyObject *swig_obj[2] ;
21386
21387 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21389 if (!SWIG_IsOK(res1)) {
21390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21391 }
21392 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21393 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21394 if (!SWIG_IsOK(ecode2)) {
21395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21396 }
21397 arg2 = static_cast< int >(val2);
21398 if (arg1) (arg1)->m_wheelRotation = arg2;
21399
21400 resultobj = SWIG_Py_Void();
21401 return resultobj;
21402 fail:
21403 return NULL;
21404 }
21405
21406
21407 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21408 PyObject *resultobj = 0;
21409 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21410 int result;
21411 void *argp1 = 0 ;
21412 int res1 = 0 ;
21413 PyObject *swig_obj[1] ;
21414
21415 if (!args) SWIG_fail;
21416 swig_obj[0] = args;
21417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21418 if (!SWIG_IsOK(res1)) {
21419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21420 }
21421 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21422 result = (int) ((arg1)->m_wheelRotation);
21423 resultobj = SWIG_From_int(static_cast< int >(result));
21424 return resultobj;
21425 fail:
21426 return NULL;
21427 }
21428
21429
21430 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21431 PyObject *resultobj = 0;
21432 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21433 int arg2 ;
21434 void *argp1 = 0 ;
21435 int res1 = 0 ;
21436 int val2 ;
21437 int ecode2 = 0 ;
21438 PyObject *swig_obj[2] ;
21439
21440 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21442 if (!SWIG_IsOK(res1)) {
21443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21444 }
21445 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21446 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21447 if (!SWIG_IsOK(ecode2)) {
21448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21449 }
21450 arg2 = static_cast< int >(val2);
21451 if (arg1) (arg1)->m_wheelDelta = arg2;
21452
21453 resultobj = SWIG_Py_Void();
21454 return resultobj;
21455 fail:
21456 return NULL;
21457 }
21458
21459
21460 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21461 PyObject *resultobj = 0;
21462 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21463 int result;
21464 void *argp1 = 0 ;
21465 int res1 = 0 ;
21466 PyObject *swig_obj[1] ;
21467
21468 if (!args) SWIG_fail;
21469 swig_obj[0] = args;
21470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21471 if (!SWIG_IsOK(res1)) {
21472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21473 }
21474 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21475 result = (int) ((arg1)->m_wheelDelta);
21476 resultobj = SWIG_From_int(static_cast< int >(result));
21477 return resultobj;
21478 fail:
21479 return NULL;
21480 }
21481
21482
21483 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21484 PyObject *resultobj = 0;
21485 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21486 int arg2 ;
21487 void *argp1 = 0 ;
21488 int res1 = 0 ;
21489 int val2 ;
21490 int ecode2 = 0 ;
21491 PyObject *swig_obj[2] ;
21492
21493 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21495 if (!SWIG_IsOK(res1)) {
21496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21497 }
21498 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21499 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21500 if (!SWIG_IsOK(ecode2)) {
21501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21502 }
21503 arg2 = static_cast< int >(val2);
21504 if (arg1) (arg1)->m_linesPerAction = arg2;
21505
21506 resultobj = SWIG_Py_Void();
21507 return resultobj;
21508 fail:
21509 return NULL;
21510 }
21511
21512
21513 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21514 PyObject *resultobj = 0;
21515 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21516 int result;
21517 void *argp1 = 0 ;
21518 int res1 = 0 ;
21519 PyObject *swig_obj[1] ;
21520
21521 if (!args) SWIG_fail;
21522 swig_obj[0] = args;
21523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21524 if (!SWIG_IsOK(res1)) {
21525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21526 }
21527 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21528 result = (int) ((arg1)->m_linesPerAction);
21529 resultobj = SWIG_From_int(static_cast< int >(result));
21530 return resultobj;
21531 fail:
21532 return NULL;
21533 }
21534
21535
21536 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21537 PyObject *obj;
21538 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21539 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21540 return SWIG_Py_Void();
21541 }
21542
21543 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21544 return SWIG_Python_InitShadowInstance(args);
21545 }
21546
21547 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21548 PyObject *resultobj = 0;
21549 int arg1 = (int) 0 ;
21550 int arg2 = (int) 0 ;
21551 wxSetCursorEvent *result = 0 ;
21552 int val1 ;
21553 int ecode1 = 0 ;
21554 int val2 ;
21555 int ecode2 = 0 ;
21556 PyObject * obj0 = 0 ;
21557 PyObject * obj1 = 0 ;
21558 char * kwnames[] = {
21559 (char *) "x",(char *) "y", NULL
21560 };
21561
21562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21563 if (obj0) {
21564 ecode1 = SWIG_AsVal_int(obj0, &val1);
21565 if (!SWIG_IsOK(ecode1)) {
21566 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21567 }
21568 arg1 = static_cast< int >(val1);
21569 }
21570 if (obj1) {
21571 ecode2 = SWIG_AsVal_int(obj1, &val2);
21572 if (!SWIG_IsOK(ecode2)) {
21573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21574 }
21575 arg2 = static_cast< int >(val2);
21576 }
21577 {
21578 PyThreadState* __tstate = wxPyBeginAllowThreads();
21579 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21580 wxPyEndAllowThreads(__tstate);
21581 if (PyErr_Occurred()) SWIG_fail;
21582 }
21583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21584 return resultobj;
21585 fail:
21586 return NULL;
21587 }
21588
21589
21590 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21591 PyObject *resultobj = 0;
21592 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21593 int result;
21594 void *argp1 = 0 ;
21595 int res1 = 0 ;
21596 PyObject *swig_obj[1] ;
21597
21598 if (!args) SWIG_fail;
21599 swig_obj[0] = args;
21600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21601 if (!SWIG_IsOK(res1)) {
21602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21603 }
21604 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21605 {
21606 PyThreadState* __tstate = wxPyBeginAllowThreads();
21607 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21608 wxPyEndAllowThreads(__tstate);
21609 if (PyErr_Occurred()) SWIG_fail;
21610 }
21611 resultobj = SWIG_From_int(static_cast< int >(result));
21612 return resultobj;
21613 fail:
21614 return NULL;
21615 }
21616
21617
21618 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21619 PyObject *resultobj = 0;
21620 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21621 int result;
21622 void *argp1 = 0 ;
21623 int res1 = 0 ;
21624 PyObject *swig_obj[1] ;
21625
21626 if (!args) SWIG_fail;
21627 swig_obj[0] = args;
21628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21629 if (!SWIG_IsOK(res1)) {
21630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21631 }
21632 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21633 {
21634 PyThreadState* __tstate = wxPyBeginAllowThreads();
21635 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21636 wxPyEndAllowThreads(__tstate);
21637 if (PyErr_Occurred()) SWIG_fail;
21638 }
21639 resultobj = SWIG_From_int(static_cast< int >(result));
21640 return resultobj;
21641 fail:
21642 return NULL;
21643 }
21644
21645
21646 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21647 PyObject *resultobj = 0;
21648 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21649 wxCursor *arg2 = 0 ;
21650 void *argp1 = 0 ;
21651 int res1 = 0 ;
21652 void *argp2 = 0 ;
21653 int res2 = 0 ;
21654 PyObject * obj0 = 0 ;
21655 PyObject * obj1 = 0 ;
21656 char * kwnames[] = {
21657 (char *) "self",(char *) "cursor", NULL
21658 };
21659
21660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21662 if (!SWIG_IsOK(res1)) {
21663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21664 }
21665 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21666 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21667 if (!SWIG_IsOK(res2)) {
21668 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21669 }
21670 if (!argp2) {
21671 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21672 }
21673 arg2 = reinterpret_cast< wxCursor * >(argp2);
21674 {
21675 PyThreadState* __tstate = wxPyBeginAllowThreads();
21676 (arg1)->SetCursor((wxCursor const &)*arg2);
21677 wxPyEndAllowThreads(__tstate);
21678 if (PyErr_Occurred()) SWIG_fail;
21679 }
21680 resultobj = SWIG_Py_Void();
21681 return resultobj;
21682 fail:
21683 return NULL;
21684 }
21685
21686
21687 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21688 PyObject *resultobj = 0;
21689 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21690 wxCursor *result = 0 ;
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_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21700 }
21701 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21702 {
21703 PyThreadState* __tstate = wxPyBeginAllowThreads();
21704 {
21705 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21706 result = (wxCursor *) &_result_ref;
21707 }
21708 wxPyEndAllowThreads(__tstate);
21709 if (PyErr_Occurred()) SWIG_fail;
21710 }
21711 {
21712 wxCursor* resultptr = new wxCursor(*result);
21713 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21714 }
21715 return resultobj;
21716 fail:
21717 return NULL;
21718 }
21719
21720
21721 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21722 PyObject *resultobj = 0;
21723 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21724 bool result;
21725 void *argp1 = 0 ;
21726 int res1 = 0 ;
21727 PyObject *swig_obj[1] ;
21728
21729 if (!args) SWIG_fail;
21730 swig_obj[0] = args;
21731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21732 if (!SWIG_IsOK(res1)) {
21733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21734 }
21735 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21736 {
21737 PyThreadState* __tstate = wxPyBeginAllowThreads();
21738 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21739 wxPyEndAllowThreads(__tstate);
21740 if (PyErr_Occurred()) SWIG_fail;
21741 }
21742 {
21743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21744 }
21745 return resultobj;
21746 fail:
21747 return NULL;
21748 }
21749
21750
21751 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21752 PyObject *obj;
21753 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21754 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21755 return SWIG_Py_Void();
21756 }
21757
21758 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21759 return SWIG_Python_InitShadowInstance(args);
21760 }
21761
21762 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21763 PyObject *resultobj = 0;
21764 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21765 wxKeyEvent *result = 0 ;
21766 int val1 ;
21767 int ecode1 = 0 ;
21768 PyObject * obj0 = 0 ;
21769 char * kwnames[] = {
21770 (char *) "eventType", NULL
21771 };
21772
21773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21774 if (obj0) {
21775 ecode1 = SWIG_AsVal_int(obj0, &val1);
21776 if (!SWIG_IsOK(ecode1)) {
21777 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21778 }
21779 arg1 = static_cast< wxEventType >(val1);
21780 }
21781 {
21782 PyThreadState* __tstate = wxPyBeginAllowThreads();
21783 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21784 wxPyEndAllowThreads(__tstate);
21785 if (PyErr_Occurred()) SWIG_fail;
21786 }
21787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21788 return resultobj;
21789 fail:
21790 return NULL;
21791 }
21792
21793
21794 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21795 PyObject *resultobj = 0;
21796 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21797 int result;
21798 void *argp1 = 0 ;
21799 int res1 = 0 ;
21800 PyObject *swig_obj[1] ;
21801
21802 if (!args) SWIG_fail;
21803 swig_obj[0] = args;
21804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21805 if (!SWIG_IsOK(res1)) {
21806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21807 }
21808 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21809 {
21810 PyThreadState* __tstate = wxPyBeginAllowThreads();
21811 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21812 wxPyEndAllowThreads(__tstate);
21813 if (PyErr_Occurred()) SWIG_fail;
21814 }
21815 resultobj = SWIG_From_int(static_cast< int >(result));
21816 return resultobj;
21817 fail:
21818 return NULL;
21819 }
21820
21821
21822 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21823 PyObject *resultobj = 0;
21824 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21825 bool result;
21826 void *argp1 = 0 ;
21827 int res1 = 0 ;
21828 PyObject *swig_obj[1] ;
21829
21830 if (!args) SWIG_fail;
21831 swig_obj[0] = args;
21832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21833 if (!SWIG_IsOK(res1)) {
21834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21835 }
21836 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21837 {
21838 PyThreadState* __tstate = wxPyBeginAllowThreads();
21839 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21840 wxPyEndAllowThreads(__tstate);
21841 if (PyErr_Occurred()) SWIG_fail;
21842 }
21843 {
21844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21845 }
21846 return resultobj;
21847 fail:
21848 return NULL;
21849 }
21850
21851
21852 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21853 PyObject *resultobj = 0;
21854 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21855 bool result;
21856 void *argp1 = 0 ;
21857 int res1 = 0 ;
21858 PyObject *swig_obj[1] ;
21859
21860 if (!args) SWIG_fail;
21861 swig_obj[0] = args;
21862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21863 if (!SWIG_IsOK(res1)) {
21864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21865 }
21866 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21867 {
21868 PyThreadState* __tstate = wxPyBeginAllowThreads();
21869 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21870 wxPyEndAllowThreads(__tstate);
21871 if (PyErr_Occurred()) SWIG_fail;
21872 }
21873 {
21874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21875 }
21876 return resultobj;
21877 fail:
21878 return NULL;
21879 }
21880
21881
21882 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21883 PyObject *resultobj = 0;
21884 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21885 bool result;
21886 void *argp1 = 0 ;
21887 int res1 = 0 ;
21888 PyObject *swig_obj[1] ;
21889
21890 if (!args) SWIG_fail;
21891 swig_obj[0] = args;
21892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21893 if (!SWIG_IsOK(res1)) {
21894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21895 }
21896 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21897 {
21898 PyThreadState* __tstate = wxPyBeginAllowThreads();
21899 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21900 wxPyEndAllowThreads(__tstate);
21901 if (PyErr_Occurred()) SWIG_fail;
21902 }
21903 {
21904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21905 }
21906 return resultobj;
21907 fail:
21908 return NULL;
21909 }
21910
21911
21912 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21913 PyObject *resultobj = 0;
21914 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21915 bool result;
21916 void *argp1 = 0 ;
21917 int res1 = 0 ;
21918 PyObject *swig_obj[1] ;
21919
21920 if (!args) SWIG_fail;
21921 swig_obj[0] = args;
21922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21923 if (!SWIG_IsOK(res1)) {
21924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21925 }
21926 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21927 {
21928 PyThreadState* __tstate = wxPyBeginAllowThreads();
21929 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
21930 wxPyEndAllowThreads(__tstate);
21931 if (PyErr_Occurred()) SWIG_fail;
21932 }
21933 {
21934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21935 }
21936 return resultobj;
21937 fail:
21938 return NULL;
21939 }
21940
21941
21942 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21943 PyObject *resultobj = 0;
21944 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21945 bool result;
21946 void *argp1 = 0 ;
21947 int res1 = 0 ;
21948 PyObject *swig_obj[1] ;
21949
21950 if (!args) SWIG_fail;
21951 swig_obj[0] = args;
21952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21953 if (!SWIG_IsOK(res1)) {
21954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21955 }
21956 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21957 {
21958 PyThreadState* __tstate = wxPyBeginAllowThreads();
21959 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
21960 wxPyEndAllowThreads(__tstate);
21961 if (PyErr_Occurred()) SWIG_fail;
21962 }
21963 {
21964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21965 }
21966 return resultobj;
21967 fail:
21968 return NULL;
21969 }
21970
21971
21972 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21973 PyObject *resultobj = 0;
21974 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21975 bool result;
21976 void *argp1 = 0 ;
21977 int res1 = 0 ;
21978 PyObject *swig_obj[1] ;
21979
21980 if (!args) SWIG_fail;
21981 swig_obj[0] = args;
21982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21983 if (!SWIG_IsOK(res1)) {
21984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21985 }
21986 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21987 {
21988 PyThreadState* __tstate = wxPyBeginAllowThreads();
21989 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
21990 wxPyEndAllowThreads(__tstate);
21991 if (PyErr_Occurred()) SWIG_fail;
21992 }
21993 {
21994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21995 }
21996 return resultobj;
21997 fail:
21998 return NULL;
21999 }
22000
22001
22002 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22003 PyObject *resultobj = 0;
22004 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22005 int result;
22006 void *argp1 = 0 ;
22007 int res1 = 0 ;
22008 PyObject *swig_obj[1] ;
22009
22010 if (!args) SWIG_fail;
22011 swig_obj[0] = args;
22012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22013 if (!SWIG_IsOK(res1)) {
22014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22015 }
22016 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22017 {
22018 PyThreadState* __tstate = wxPyBeginAllowThreads();
22019 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22020 wxPyEndAllowThreads(__tstate);
22021 if (PyErr_Occurred()) SWIG_fail;
22022 }
22023 resultobj = SWIG_From_int(static_cast< int >(result));
22024 return resultobj;
22025 fail:
22026 return NULL;
22027 }
22028
22029
22030 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22031 PyObject *resultobj = 0;
22032 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22033 int result;
22034 void *argp1 = 0 ;
22035 int res1 = 0 ;
22036 PyObject *swig_obj[1] ;
22037
22038 if (!args) SWIG_fail;
22039 swig_obj[0] = args;
22040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22041 if (!SWIG_IsOK(res1)) {
22042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22043 }
22044 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22045 {
22046 PyThreadState* __tstate = wxPyBeginAllowThreads();
22047 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22048 wxPyEndAllowThreads(__tstate);
22049 if (PyErr_Occurred()) SWIG_fail;
22050 }
22051 resultobj = SWIG_From_int(static_cast< int >(result));
22052 return resultobj;
22053 fail:
22054 return NULL;
22055 }
22056
22057
22058 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22059 PyObject *resultobj = 0;
22060 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22061 unsigned int result;
22062 void *argp1 = 0 ;
22063 int res1 = 0 ;
22064 PyObject *swig_obj[1] ;
22065
22066 if (!args) SWIG_fail;
22067 swig_obj[0] = args;
22068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22069 if (!SWIG_IsOK(res1)) {
22070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22071 }
22072 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22073 {
22074 PyThreadState* __tstate = wxPyBeginAllowThreads();
22075 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22076 wxPyEndAllowThreads(__tstate);
22077 if (PyErr_Occurred()) SWIG_fail;
22078 }
22079 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22080 return resultobj;
22081 fail:
22082 return NULL;
22083 }
22084
22085
22086 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22087 PyObject *resultobj = 0;
22088 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22089 unsigned int result;
22090 void *argp1 = 0 ;
22091 int res1 = 0 ;
22092 PyObject *swig_obj[1] ;
22093
22094 if (!args) SWIG_fail;
22095 swig_obj[0] = args;
22096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22097 if (!SWIG_IsOK(res1)) {
22098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22099 }
22100 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22101 {
22102 PyThreadState* __tstate = wxPyBeginAllowThreads();
22103 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22104 wxPyEndAllowThreads(__tstate);
22105 if (PyErr_Occurred()) SWIG_fail;
22106 }
22107 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22108 return resultobj;
22109 fail:
22110 return NULL;
22111 }
22112
22113
22114 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22115 PyObject *resultobj = 0;
22116 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22117 wxPoint result;
22118 void *argp1 = 0 ;
22119 int res1 = 0 ;
22120 PyObject *swig_obj[1] ;
22121
22122 if (!args) SWIG_fail;
22123 swig_obj[0] = args;
22124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22125 if (!SWIG_IsOK(res1)) {
22126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22127 }
22128 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22129 {
22130 PyThreadState* __tstate = wxPyBeginAllowThreads();
22131 result = (arg1)->GetPosition();
22132 wxPyEndAllowThreads(__tstate);
22133 if (PyErr_Occurred()) SWIG_fail;
22134 }
22135 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22136 return resultobj;
22137 fail:
22138 return NULL;
22139 }
22140
22141
22142 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22143 PyObject *resultobj = 0;
22144 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22145 long *arg2 = (long *) 0 ;
22146 long *arg3 = (long *) 0 ;
22147 void *argp1 = 0 ;
22148 int res1 = 0 ;
22149 long temp2 ;
22150 int res2 = SWIG_TMPOBJ ;
22151 long temp3 ;
22152 int res3 = SWIG_TMPOBJ ;
22153 PyObject *swig_obj[1] ;
22154
22155 arg2 = &temp2;
22156 arg3 = &temp3;
22157 if (!args) SWIG_fail;
22158 swig_obj[0] = args;
22159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22160 if (!SWIG_IsOK(res1)) {
22161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22162 }
22163 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22164 {
22165 PyThreadState* __tstate = wxPyBeginAllowThreads();
22166 (arg1)->GetPosition(arg2,arg3);
22167 wxPyEndAllowThreads(__tstate);
22168 if (PyErr_Occurred()) SWIG_fail;
22169 }
22170 resultobj = SWIG_Py_Void();
22171 if (SWIG_IsTmpObj(res2)) {
22172 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22173 } else {
22174 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22175 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22176 }
22177 if (SWIG_IsTmpObj(res3)) {
22178 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22179 } else {
22180 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22181 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22182 }
22183 return resultobj;
22184 fail:
22185 return NULL;
22186 }
22187
22188
22189 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22190 PyObject *resultobj = 0;
22191 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22192 int result;
22193 void *argp1 = 0 ;
22194 int res1 = 0 ;
22195 PyObject *swig_obj[1] ;
22196
22197 if (!args) SWIG_fail;
22198 swig_obj[0] = args;
22199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22200 if (!SWIG_IsOK(res1)) {
22201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22202 }
22203 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22204 {
22205 PyThreadState* __tstate = wxPyBeginAllowThreads();
22206 result = (int)((wxKeyEvent const *)arg1)->GetX();
22207 wxPyEndAllowThreads(__tstate);
22208 if (PyErr_Occurred()) SWIG_fail;
22209 }
22210 resultobj = SWIG_From_int(static_cast< int >(result));
22211 return resultobj;
22212 fail:
22213 return NULL;
22214 }
22215
22216
22217 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22218 PyObject *resultobj = 0;
22219 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22220 int result;
22221 void *argp1 = 0 ;
22222 int res1 = 0 ;
22223 PyObject *swig_obj[1] ;
22224
22225 if (!args) SWIG_fail;
22226 swig_obj[0] = args;
22227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22228 if (!SWIG_IsOK(res1)) {
22229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22230 }
22231 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22232 {
22233 PyThreadState* __tstate = wxPyBeginAllowThreads();
22234 result = (int)((wxKeyEvent const *)arg1)->GetY();
22235 wxPyEndAllowThreads(__tstate);
22236 if (PyErr_Occurred()) SWIG_fail;
22237 }
22238 resultobj = SWIG_From_int(static_cast< int >(result));
22239 return resultobj;
22240 fail:
22241 return NULL;
22242 }
22243
22244
22245 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22246 PyObject *resultobj = 0;
22247 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22248 int arg2 ;
22249 void *argp1 = 0 ;
22250 int res1 = 0 ;
22251 int val2 ;
22252 int ecode2 = 0 ;
22253 PyObject *swig_obj[2] ;
22254
22255 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22257 if (!SWIG_IsOK(res1)) {
22258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22259 }
22260 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22261 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22262 if (!SWIG_IsOK(ecode2)) {
22263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22264 }
22265 arg2 = static_cast< int >(val2);
22266 if (arg1) (arg1)->m_x = arg2;
22267
22268 resultobj = SWIG_Py_Void();
22269 return resultobj;
22270 fail:
22271 return NULL;
22272 }
22273
22274
22275 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22276 PyObject *resultobj = 0;
22277 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22278 int result;
22279 void *argp1 = 0 ;
22280 int res1 = 0 ;
22281 PyObject *swig_obj[1] ;
22282
22283 if (!args) SWIG_fail;
22284 swig_obj[0] = args;
22285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22286 if (!SWIG_IsOK(res1)) {
22287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22288 }
22289 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22290 result = (int) ((arg1)->m_x);
22291 resultobj = SWIG_From_int(static_cast< int >(result));
22292 return resultobj;
22293 fail:
22294 return NULL;
22295 }
22296
22297
22298 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22299 PyObject *resultobj = 0;
22300 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22301 int arg2 ;
22302 void *argp1 = 0 ;
22303 int res1 = 0 ;
22304 int val2 ;
22305 int ecode2 = 0 ;
22306 PyObject *swig_obj[2] ;
22307
22308 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22310 if (!SWIG_IsOK(res1)) {
22311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22312 }
22313 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22314 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22315 if (!SWIG_IsOK(ecode2)) {
22316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22317 }
22318 arg2 = static_cast< int >(val2);
22319 if (arg1) (arg1)->m_y = arg2;
22320
22321 resultobj = SWIG_Py_Void();
22322 return resultobj;
22323 fail:
22324 return NULL;
22325 }
22326
22327
22328 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22329 PyObject *resultobj = 0;
22330 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22331 int result;
22332 void *argp1 = 0 ;
22333 int res1 = 0 ;
22334 PyObject *swig_obj[1] ;
22335
22336 if (!args) SWIG_fail;
22337 swig_obj[0] = args;
22338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22339 if (!SWIG_IsOK(res1)) {
22340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22341 }
22342 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22343 result = (int) ((arg1)->m_y);
22344 resultobj = SWIG_From_int(static_cast< int >(result));
22345 return resultobj;
22346 fail:
22347 return NULL;
22348 }
22349
22350
22351 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22352 PyObject *resultobj = 0;
22353 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22354 long arg2 ;
22355 void *argp1 = 0 ;
22356 int res1 = 0 ;
22357 long val2 ;
22358 int ecode2 = 0 ;
22359 PyObject *swig_obj[2] ;
22360
22361 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
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_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22365 }
22366 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22367 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22368 if (!SWIG_IsOK(ecode2)) {
22369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22370 }
22371 arg2 = static_cast< long >(val2);
22372 if (arg1) (arg1)->m_keyCode = arg2;
22373
22374 resultobj = SWIG_Py_Void();
22375 return resultobj;
22376 fail:
22377 return NULL;
22378 }
22379
22380
22381 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22382 PyObject *resultobj = 0;
22383 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22384 long result;
22385 void *argp1 = 0 ;
22386 int res1 = 0 ;
22387 PyObject *swig_obj[1] ;
22388
22389 if (!args) SWIG_fail;
22390 swig_obj[0] = args;
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_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22394 }
22395 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22396 result = (long) ((arg1)->m_keyCode);
22397 resultobj = SWIG_From_long(static_cast< long >(result));
22398 return resultobj;
22399 fail:
22400 return NULL;
22401 }
22402
22403
22404 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22405 PyObject *resultobj = 0;
22406 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22407 bool arg2 ;
22408 void *argp1 = 0 ;
22409 int res1 = 0 ;
22410 bool val2 ;
22411 int ecode2 = 0 ;
22412 PyObject *swig_obj[2] ;
22413
22414 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22416 if (!SWIG_IsOK(res1)) {
22417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22418 }
22419 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22420 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22421 if (!SWIG_IsOK(ecode2)) {
22422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22423 }
22424 arg2 = static_cast< bool >(val2);
22425 if (arg1) (arg1)->m_controlDown = arg2;
22426
22427 resultobj = SWIG_Py_Void();
22428 return resultobj;
22429 fail:
22430 return NULL;
22431 }
22432
22433
22434 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22435 PyObject *resultobj = 0;
22436 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22437 bool result;
22438 void *argp1 = 0 ;
22439 int res1 = 0 ;
22440 PyObject *swig_obj[1] ;
22441
22442 if (!args) SWIG_fail;
22443 swig_obj[0] = args;
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_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22447 }
22448 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22449 result = (bool) ((arg1)->m_controlDown);
22450 {
22451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22452 }
22453 return resultobj;
22454 fail:
22455 return NULL;
22456 }
22457
22458
22459 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22460 PyObject *resultobj = 0;
22461 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22462 bool arg2 ;
22463 void *argp1 = 0 ;
22464 int res1 = 0 ;
22465 bool val2 ;
22466 int ecode2 = 0 ;
22467 PyObject *swig_obj[2] ;
22468
22469 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22471 if (!SWIG_IsOK(res1)) {
22472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22473 }
22474 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22475 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22476 if (!SWIG_IsOK(ecode2)) {
22477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22478 }
22479 arg2 = static_cast< bool >(val2);
22480 if (arg1) (arg1)->m_shiftDown = arg2;
22481
22482 resultobj = SWIG_Py_Void();
22483 return resultobj;
22484 fail:
22485 return NULL;
22486 }
22487
22488
22489 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22490 PyObject *resultobj = 0;
22491 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22492 bool result;
22493 void *argp1 = 0 ;
22494 int res1 = 0 ;
22495 PyObject *swig_obj[1] ;
22496
22497 if (!args) SWIG_fail;
22498 swig_obj[0] = args;
22499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22500 if (!SWIG_IsOK(res1)) {
22501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22502 }
22503 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22504 result = (bool) ((arg1)->m_shiftDown);
22505 {
22506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22507 }
22508 return resultobj;
22509 fail:
22510 return NULL;
22511 }
22512
22513
22514 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22515 PyObject *resultobj = 0;
22516 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22517 bool arg2 ;
22518 void *argp1 = 0 ;
22519 int res1 = 0 ;
22520 bool val2 ;
22521 int ecode2 = 0 ;
22522 PyObject *swig_obj[2] ;
22523
22524 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22526 if (!SWIG_IsOK(res1)) {
22527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22528 }
22529 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22530 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22531 if (!SWIG_IsOK(ecode2)) {
22532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22533 }
22534 arg2 = static_cast< bool >(val2);
22535 if (arg1) (arg1)->m_altDown = arg2;
22536
22537 resultobj = SWIG_Py_Void();
22538 return resultobj;
22539 fail:
22540 return NULL;
22541 }
22542
22543
22544 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22545 PyObject *resultobj = 0;
22546 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22547 bool result;
22548 void *argp1 = 0 ;
22549 int res1 = 0 ;
22550 PyObject *swig_obj[1] ;
22551
22552 if (!args) SWIG_fail;
22553 swig_obj[0] = args;
22554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22555 if (!SWIG_IsOK(res1)) {
22556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22557 }
22558 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22559 result = (bool) ((arg1)->m_altDown);
22560 {
22561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22562 }
22563 return resultobj;
22564 fail:
22565 return NULL;
22566 }
22567
22568
22569 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22570 PyObject *resultobj = 0;
22571 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22572 bool arg2 ;
22573 void *argp1 = 0 ;
22574 int res1 = 0 ;
22575 bool val2 ;
22576 int ecode2 = 0 ;
22577 PyObject *swig_obj[2] ;
22578
22579 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22581 if (!SWIG_IsOK(res1)) {
22582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22583 }
22584 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22585 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22586 if (!SWIG_IsOK(ecode2)) {
22587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22588 }
22589 arg2 = static_cast< bool >(val2);
22590 if (arg1) (arg1)->m_metaDown = arg2;
22591
22592 resultobj = SWIG_Py_Void();
22593 return resultobj;
22594 fail:
22595 return NULL;
22596 }
22597
22598
22599 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22600 PyObject *resultobj = 0;
22601 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22602 bool result;
22603 void *argp1 = 0 ;
22604 int res1 = 0 ;
22605 PyObject *swig_obj[1] ;
22606
22607 if (!args) SWIG_fail;
22608 swig_obj[0] = args;
22609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22610 if (!SWIG_IsOK(res1)) {
22611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22612 }
22613 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22614 result = (bool) ((arg1)->m_metaDown);
22615 {
22616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22617 }
22618 return resultobj;
22619 fail:
22620 return NULL;
22621 }
22622
22623
22624 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22625 PyObject *resultobj = 0;
22626 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22627 bool arg2 ;
22628 void *argp1 = 0 ;
22629 int res1 = 0 ;
22630 bool val2 ;
22631 int ecode2 = 0 ;
22632 PyObject *swig_obj[2] ;
22633
22634 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22636 if (!SWIG_IsOK(res1)) {
22637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22638 }
22639 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22640 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22641 if (!SWIG_IsOK(ecode2)) {
22642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22643 }
22644 arg2 = static_cast< bool >(val2);
22645 if (arg1) (arg1)->m_scanCode = arg2;
22646
22647 resultobj = SWIG_Py_Void();
22648 return resultobj;
22649 fail:
22650 return NULL;
22651 }
22652
22653
22654 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22655 PyObject *resultobj = 0;
22656 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22657 bool result;
22658 void *argp1 = 0 ;
22659 int res1 = 0 ;
22660 PyObject *swig_obj[1] ;
22661
22662 if (!args) SWIG_fail;
22663 swig_obj[0] = args;
22664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22665 if (!SWIG_IsOK(res1)) {
22666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22667 }
22668 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22669 result = (bool) ((arg1)->m_scanCode);
22670 {
22671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22672 }
22673 return resultobj;
22674 fail:
22675 return NULL;
22676 }
22677
22678
22679 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22680 PyObject *resultobj = 0;
22681 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22682 unsigned int arg2 ;
22683 void *argp1 = 0 ;
22684 int res1 = 0 ;
22685 unsigned int val2 ;
22686 int ecode2 = 0 ;
22687 PyObject *swig_obj[2] ;
22688
22689 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22691 if (!SWIG_IsOK(res1)) {
22692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22693 }
22694 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22695 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22696 if (!SWIG_IsOK(ecode2)) {
22697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22698 }
22699 arg2 = static_cast< unsigned int >(val2);
22700 if (arg1) (arg1)->m_rawCode = arg2;
22701
22702 resultobj = SWIG_Py_Void();
22703 return resultobj;
22704 fail:
22705 return NULL;
22706 }
22707
22708
22709 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22710 PyObject *resultobj = 0;
22711 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22712 unsigned int result;
22713 void *argp1 = 0 ;
22714 int res1 = 0 ;
22715 PyObject *swig_obj[1] ;
22716
22717 if (!args) SWIG_fail;
22718 swig_obj[0] = args;
22719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22720 if (!SWIG_IsOK(res1)) {
22721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22722 }
22723 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22724 result = (unsigned int) ((arg1)->m_rawCode);
22725 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22726 return resultobj;
22727 fail:
22728 return NULL;
22729 }
22730
22731
22732 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22733 PyObject *resultobj = 0;
22734 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22735 unsigned int arg2 ;
22736 void *argp1 = 0 ;
22737 int res1 = 0 ;
22738 unsigned int val2 ;
22739 int ecode2 = 0 ;
22740 PyObject *swig_obj[2] ;
22741
22742 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22744 if (!SWIG_IsOK(res1)) {
22745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22746 }
22747 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22748 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22749 if (!SWIG_IsOK(ecode2)) {
22750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22751 }
22752 arg2 = static_cast< unsigned int >(val2);
22753 if (arg1) (arg1)->m_rawFlags = arg2;
22754
22755 resultobj = SWIG_Py_Void();
22756 return resultobj;
22757 fail:
22758 return NULL;
22759 }
22760
22761
22762 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22763 PyObject *resultobj = 0;
22764 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22765 unsigned int result;
22766 void *argp1 = 0 ;
22767 int res1 = 0 ;
22768 PyObject *swig_obj[1] ;
22769
22770 if (!args) SWIG_fail;
22771 swig_obj[0] = args;
22772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22773 if (!SWIG_IsOK(res1)) {
22774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22775 }
22776 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22777 result = (unsigned int) ((arg1)->m_rawFlags);
22778 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22779 return resultobj;
22780 fail:
22781 return NULL;
22782 }
22783
22784
22785 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22786 PyObject *obj;
22787 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22788 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22789 return SWIG_Py_Void();
22790 }
22791
22792 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22793 return SWIG_Python_InitShadowInstance(args);
22794 }
22795
22796 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22797 PyObject *resultobj = 0;
22798 wxSize const &arg1_defvalue = wxDefaultSize ;
22799 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22800 int arg2 = (int) 0 ;
22801 wxSizeEvent *result = 0 ;
22802 wxSize temp1 ;
22803 int val2 ;
22804 int ecode2 = 0 ;
22805 PyObject * obj0 = 0 ;
22806 PyObject * obj1 = 0 ;
22807 char * kwnames[] = {
22808 (char *) "sz",(char *) "winid", NULL
22809 };
22810
22811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22812 if (obj0) {
22813 {
22814 arg1 = &temp1;
22815 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22816 }
22817 }
22818 if (obj1) {
22819 ecode2 = SWIG_AsVal_int(obj1, &val2);
22820 if (!SWIG_IsOK(ecode2)) {
22821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22822 }
22823 arg2 = static_cast< int >(val2);
22824 }
22825 {
22826 PyThreadState* __tstate = wxPyBeginAllowThreads();
22827 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22828 wxPyEndAllowThreads(__tstate);
22829 if (PyErr_Occurred()) SWIG_fail;
22830 }
22831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22832 return resultobj;
22833 fail:
22834 return NULL;
22835 }
22836
22837
22838 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22839 PyObject *resultobj = 0;
22840 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22841 wxSize result;
22842 void *argp1 = 0 ;
22843 int res1 = 0 ;
22844 PyObject *swig_obj[1] ;
22845
22846 if (!args) SWIG_fail;
22847 swig_obj[0] = args;
22848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22849 if (!SWIG_IsOK(res1)) {
22850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22851 }
22852 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22853 {
22854 PyThreadState* __tstate = wxPyBeginAllowThreads();
22855 result = ((wxSizeEvent const *)arg1)->GetSize();
22856 wxPyEndAllowThreads(__tstate);
22857 if (PyErr_Occurred()) SWIG_fail;
22858 }
22859 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22860 return resultobj;
22861 fail:
22862 return NULL;
22863 }
22864
22865
22866 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22867 PyObject *resultobj = 0;
22868 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22869 wxRect result;
22870 void *argp1 = 0 ;
22871 int res1 = 0 ;
22872 PyObject *swig_obj[1] ;
22873
22874 if (!args) SWIG_fail;
22875 swig_obj[0] = args;
22876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22877 if (!SWIG_IsOK(res1)) {
22878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22879 }
22880 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22881 {
22882 PyThreadState* __tstate = wxPyBeginAllowThreads();
22883 result = ((wxSizeEvent const *)arg1)->GetRect();
22884 wxPyEndAllowThreads(__tstate);
22885 if (PyErr_Occurred()) SWIG_fail;
22886 }
22887 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22888 return resultobj;
22889 fail:
22890 return NULL;
22891 }
22892
22893
22894 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22895 PyObject *resultobj = 0;
22896 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22897 wxRect arg2 ;
22898 void *argp1 = 0 ;
22899 int res1 = 0 ;
22900 void *argp2 ;
22901 int res2 = 0 ;
22902 PyObject * obj0 = 0 ;
22903 PyObject * obj1 = 0 ;
22904 char * kwnames[] = {
22905 (char *) "self",(char *) "rect", NULL
22906 };
22907
22908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
22909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22910 if (!SWIG_IsOK(res1)) {
22911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22912 }
22913 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22914 {
22915 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
22916 if (!SWIG_IsOK(res2)) {
22917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22918 }
22919 if (!argp2) {
22920 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22921 } else {
22922 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
22923 arg2 = *temp;
22924 if (SWIG_IsNewObj(res2)) delete temp;
22925 }
22926 }
22927 {
22928 PyThreadState* __tstate = wxPyBeginAllowThreads();
22929 (arg1)->SetRect(arg2);
22930 wxPyEndAllowThreads(__tstate);
22931 if (PyErr_Occurred()) SWIG_fail;
22932 }
22933 resultobj = SWIG_Py_Void();
22934 return resultobj;
22935 fail:
22936 return NULL;
22937 }
22938
22939
22940 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22941 PyObject *resultobj = 0;
22942 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22943 wxSize arg2 ;
22944 void *argp1 = 0 ;
22945 int res1 = 0 ;
22946 void *argp2 ;
22947 int res2 = 0 ;
22948 PyObject * obj0 = 0 ;
22949 PyObject * obj1 = 0 ;
22950 char * kwnames[] = {
22951 (char *) "self",(char *) "size", NULL
22952 };
22953
22954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
22955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22956 if (!SWIG_IsOK(res1)) {
22957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22958 }
22959 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22960 {
22961 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
22962 if (!SWIG_IsOK(res2)) {
22963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
22964 }
22965 if (!argp2) {
22966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
22967 } else {
22968 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
22969 arg2 = *temp;
22970 if (SWIG_IsNewObj(res2)) delete temp;
22971 }
22972 }
22973 {
22974 PyThreadState* __tstate = wxPyBeginAllowThreads();
22975 wxSizeEvent_SetSize(arg1,arg2);
22976 wxPyEndAllowThreads(__tstate);
22977 if (PyErr_Occurred()) SWIG_fail;
22978 }
22979 resultobj = SWIG_Py_Void();
22980 return resultobj;
22981 fail:
22982 return NULL;
22983 }
22984
22985
22986 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22987 PyObject *resultobj = 0;
22988 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22989 wxSize *arg2 = (wxSize *) 0 ;
22990 void *argp1 = 0 ;
22991 int res1 = 0 ;
22992 void *argp2 = 0 ;
22993 int res2 = 0 ;
22994 PyObject *swig_obj[2] ;
22995
22996 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
22997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22998 if (!SWIG_IsOK(res1)) {
22999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23000 }
23001 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23002 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23003 if (!SWIG_IsOK(res2)) {
23004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23005 }
23006 arg2 = reinterpret_cast< wxSize * >(argp2);
23007 if (arg1) (arg1)->m_size = *arg2;
23008
23009 resultobj = SWIG_Py_Void();
23010 return resultobj;
23011 fail:
23012 return NULL;
23013 }
23014
23015
23016 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23017 PyObject *resultobj = 0;
23018 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23019 wxSize *result = 0 ;
23020 void *argp1 = 0 ;
23021 int res1 = 0 ;
23022 PyObject *swig_obj[1] ;
23023
23024 if (!args) SWIG_fail;
23025 swig_obj[0] = args;
23026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23027 if (!SWIG_IsOK(res1)) {
23028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23029 }
23030 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23031 result = (wxSize *)& ((arg1)->m_size);
23032 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23033 return resultobj;
23034 fail:
23035 return NULL;
23036 }
23037
23038
23039 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23040 PyObject *resultobj = 0;
23041 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23042 wxRect *arg2 = (wxRect *) 0 ;
23043 void *argp1 = 0 ;
23044 int res1 = 0 ;
23045 void *argp2 = 0 ;
23046 int res2 = 0 ;
23047 PyObject *swig_obj[2] ;
23048
23049 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23051 if (!SWIG_IsOK(res1)) {
23052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23053 }
23054 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23055 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23056 if (!SWIG_IsOK(res2)) {
23057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23058 }
23059 arg2 = reinterpret_cast< wxRect * >(argp2);
23060 if (arg1) (arg1)->m_rect = *arg2;
23061
23062 resultobj = SWIG_Py_Void();
23063 return resultobj;
23064 fail:
23065 return NULL;
23066 }
23067
23068
23069 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23070 PyObject *resultobj = 0;
23071 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23072 wxRect *result = 0 ;
23073 void *argp1 = 0 ;
23074 int res1 = 0 ;
23075 PyObject *swig_obj[1] ;
23076
23077 if (!args) SWIG_fail;
23078 swig_obj[0] = args;
23079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23080 if (!SWIG_IsOK(res1)) {
23081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23082 }
23083 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23084 result = (wxRect *)& ((arg1)->m_rect);
23085 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23086 return resultobj;
23087 fail:
23088 return NULL;
23089 }
23090
23091
23092 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23093 PyObject *obj;
23094 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23095 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23096 return SWIG_Py_Void();
23097 }
23098
23099 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23100 return SWIG_Python_InitShadowInstance(args);
23101 }
23102
23103 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23104 PyObject *resultobj = 0;
23105 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23106 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23107 int arg2 = (int) 0 ;
23108 wxMoveEvent *result = 0 ;
23109 wxPoint temp1 ;
23110 int val2 ;
23111 int ecode2 = 0 ;
23112 PyObject * obj0 = 0 ;
23113 PyObject * obj1 = 0 ;
23114 char * kwnames[] = {
23115 (char *) "pos",(char *) "winid", NULL
23116 };
23117
23118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23119 if (obj0) {
23120 {
23121 arg1 = &temp1;
23122 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23123 }
23124 }
23125 if (obj1) {
23126 ecode2 = SWIG_AsVal_int(obj1, &val2);
23127 if (!SWIG_IsOK(ecode2)) {
23128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23129 }
23130 arg2 = static_cast< int >(val2);
23131 }
23132 {
23133 PyThreadState* __tstate = wxPyBeginAllowThreads();
23134 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23135 wxPyEndAllowThreads(__tstate);
23136 if (PyErr_Occurred()) SWIG_fail;
23137 }
23138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23139 return resultobj;
23140 fail:
23141 return NULL;
23142 }
23143
23144
23145 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23146 PyObject *resultobj = 0;
23147 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23148 wxPoint result;
23149 void *argp1 = 0 ;
23150 int res1 = 0 ;
23151 PyObject *swig_obj[1] ;
23152
23153 if (!args) SWIG_fail;
23154 swig_obj[0] = args;
23155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23156 if (!SWIG_IsOK(res1)) {
23157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23158 }
23159 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23160 {
23161 PyThreadState* __tstate = wxPyBeginAllowThreads();
23162 result = ((wxMoveEvent const *)arg1)->GetPosition();
23163 wxPyEndAllowThreads(__tstate);
23164 if (PyErr_Occurred()) SWIG_fail;
23165 }
23166 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23167 return resultobj;
23168 fail:
23169 return NULL;
23170 }
23171
23172
23173 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23174 PyObject *resultobj = 0;
23175 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23176 wxRect result;
23177 void *argp1 = 0 ;
23178 int res1 = 0 ;
23179 PyObject *swig_obj[1] ;
23180
23181 if (!args) SWIG_fail;
23182 swig_obj[0] = args;
23183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23184 if (!SWIG_IsOK(res1)) {
23185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23186 }
23187 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23188 {
23189 PyThreadState* __tstate = wxPyBeginAllowThreads();
23190 result = ((wxMoveEvent const *)arg1)->GetRect();
23191 wxPyEndAllowThreads(__tstate);
23192 if (PyErr_Occurred()) SWIG_fail;
23193 }
23194 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23195 return resultobj;
23196 fail:
23197 return NULL;
23198 }
23199
23200
23201 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23202 PyObject *resultobj = 0;
23203 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23204 wxRect *arg2 = 0 ;
23205 void *argp1 = 0 ;
23206 int res1 = 0 ;
23207 wxRect temp2 ;
23208 PyObject * obj0 = 0 ;
23209 PyObject * obj1 = 0 ;
23210 char * kwnames[] = {
23211 (char *) "self",(char *) "rect", NULL
23212 };
23213
23214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23216 if (!SWIG_IsOK(res1)) {
23217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23218 }
23219 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23220 {
23221 arg2 = &temp2;
23222 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23223 }
23224 {
23225 PyThreadState* __tstate = wxPyBeginAllowThreads();
23226 (arg1)->SetRect((wxRect const &)*arg2);
23227 wxPyEndAllowThreads(__tstate);
23228 if (PyErr_Occurred()) SWIG_fail;
23229 }
23230 resultobj = SWIG_Py_Void();
23231 return resultobj;
23232 fail:
23233 return NULL;
23234 }
23235
23236
23237 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23238 PyObject *resultobj = 0;
23239 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23240 wxPoint *arg2 = 0 ;
23241 void *argp1 = 0 ;
23242 int res1 = 0 ;
23243 wxPoint temp2 ;
23244 PyObject * obj0 = 0 ;
23245 PyObject * obj1 = 0 ;
23246 char * kwnames[] = {
23247 (char *) "self",(char *) "pos", NULL
23248 };
23249
23250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23252 if (!SWIG_IsOK(res1)) {
23253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23254 }
23255 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23256 {
23257 arg2 = &temp2;
23258 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23259 }
23260 {
23261 PyThreadState* __tstate = wxPyBeginAllowThreads();
23262 (arg1)->SetPosition((wxPoint const &)*arg2);
23263 wxPyEndAllowThreads(__tstate);
23264 if (PyErr_Occurred()) SWIG_fail;
23265 }
23266 resultobj = SWIG_Py_Void();
23267 return resultobj;
23268 fail:
23269 return NULL;
23270 }
23271
23272
23273 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23274 PyObject *obj;
23275 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23276 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23277 return SWIG_Py_Void();
23278 }
23279
23280 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23281 return SWIG_Python_InitShadowInstance(args);
23282 }
23283
23284 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23285 PyObject *resultobj = 0;
23286 int arg1 = (int) 0 ;
23287 wxPaintEvent *result = 0 ;
23288 int val1 ;
23289 int ecode1 = 0 ;
23290 PyObject * obj0 = 0 ;
23291 char * kwnames[] = {
23292 (char *) "Id", NULL
23293 };
23294
23295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23296 if (obj0) {
23297 ecode1 = SWIG_AsVal_int(obj0, &val1);
23298 if (!SWIG_IsOK(ecode1)) {
23299 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23300 }
23301 arg1 = static_cast< int >(val1);
23302 }
23303 {
23304 PyThreadState* __tstate = wxPyBeginAllowThreads();
23305 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23306 wxPyEndAllowThreads(__tstate);
23307 if (PyErr_Occurred()) SWIG_fail;
23308 }
23309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23310 return resultobj;
23311 fail:
23312 return NULL;
23313 }
23314
23315
23316 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23317 PyObject *obj;
23318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23319 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23320 return SWIG_Py_Void();
23321 }
23322
23323 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23324 return SWIG_Python_InitShadowInstance(args);
23325 }
23326
23327 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23328 PyObject *resultobj = 0;
23329 int arg1 = (int) 0 ;
23330 wxNcPaintEvent *result = 0 ;
23331 int val1 ;
23332 int ecode1 = 0 ;
23333 PyObject * obj0 = 0 ;
23334 char * kwnames[] = {
23335 (char *) "winid", NULL
23336 };
23337
23338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23339 if (obj0) {
23340 ecode1 = SWIG_AsVal_int(obj0, &val1);
23341 if (!SWIG_IsOK(ecode1)) {
23342 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23343 }
23344 arg1 = static_cast< int >(val1);
23345 }
23346 {
23347 PyThreadState* __tstate = wxPyBeginAllowThreads();
23348 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23349 wxPyEndAllowThreads(__tstate);
23350 if (PyErr_Occurred()) SWIG_fail;
23351 }
23352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23353 return resultobj;
23354 fail:
23355 return NULL;
23356 }
23357
23358
23359 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23360 PyObject *obj;
23361 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23362 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23363 return SWIG_Py_Void();
23364 }
23365
23366 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23367 return SWIG_Python_InitShadowInstance(args);
23368 }
23369
23370 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23371 PyObject *resultobj = 0;
23372 int arg1 = (int) 0 ;
23373 wxDC *arg2 = (wxDC *) NULL ;
23374 wxEraseEvent *result = 0 ;
23375 int val1 ;
23376 int ecode1 = 0 ;
23377 void *argp2 = 0 ;
23378 int res2 = 0 ;
23379 PyObject * obj0 = 0 ;
23380 PyObject * obj1 = 0 ;
23381 char * kwnames[] = {
23382 (char *) "Id",(char *) "dc", NULL
23383 };
23384
23385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23386 if (obj0) {
23387 ecode1 = SWIG_AsVal_int(obj0, &val1);
23388 if (!SWIG_IsOK(ecode1)) {
23389 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23390 }
23391 arg1 = static_cast< int >(val1);
23392 }
23393 if (obj1) {
23394 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23395 if (!SWIG_IsOK(res2)) {
23396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23397 }
23398 arg2 = reinterpret_cast< wxDC * >(argp2);
23399 }
23400 {
23401 PyThreadState* __tstate = wxPyBeginAllowThreads();
23402 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23403 wxPyEndAllowThreads(__tstate);
23404 if (PyErr_Occurred()) SWIG_fail;
23405 }
23406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23407 return resultobj;
23408 fail:
23409 return NULL;
23410 }
23411
23412
23413 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23414 PyObject *resultobj = 0;
23415 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23416 wxDC *result = 0 ;
23417 void *argp1 = 0 ;
23418 int res1 = 0 ;
23419 PyObject *swig_obj[1] ;
23420
23421 if (!args) SWIG_fail;
23422 swig_obj[0] = args;
23423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23424 if (!SWIG_IsOK(res1)) {
23425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23426 }
23427 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23428 {
23429 PyThreadState* __tstate = wxPyBeginAllowThreads();
23430 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23431 wxPyEndAllowThreads(__tstate);
23432 if (PyErr_Occurred()) SWIG_fail;
23433 }
23434 {
23435 resultobj = wxPyMake_wxObject(result, (bool)0);
23436 }
23437 return resultobj;
23438 fail:
23439 return NULL;
23440 }
23441
23442
23443 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23444 PyObject *obj;
23445 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23446 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23447 return SWIG_Py_Void();
23448 }
23449
23450 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23451 return SWIG_Python_InitShadowInstance(args);
23452 }
23453
23454 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23455 PyObject *resultobj = 0;
23456 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23457 int arg2 = (int) 0 ;
23458 wxFocusEvent *result = 0 ;
23459 int val1 ;
23460 int ecode1 = 0 ;
23461 int val2 ;
23462 int ecode2 = 0 ;
23463 PyObject * obj0 = 0 ;
23464 PyObject * obj1 = 0 ;
23465 char * kwnames[] = {
23466 (char *) "type",(char *) "winid", NULL
23467 };
23468
23469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23470 if (obj0) {
23471 ecode1 = SWIG_AsVal_int(obj0, &val1);
23472 if (!SWIG_IsOK(ecode1)) {
23473 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23474 }
23475 arg1 = static_cast< wxEventType >(val1);
23476 }
23477 if (obj1) {
23478 ecode2 = SWIG_AsVal_int(obj1, &val2);
23479 if (!SWIG_IsOK(ecode2)) {
23480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23481 }
23482 arg2 = static_cast< int >(val2);
23483 }
23484 {
23485 PyThreadState* __tstate = wxPyBeginAllowThreads();
23486 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23487 wxPyEndAllowThreads(__tstate);
23488 if (PyErr_Occurred()) SWIG_fail;
23489 }
23490 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23491 return resultobj;
23492 fail:
23493 return NULL;
23494 }
23495
23496
23497 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23498 PyObject *resultobj = 0;
23499 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23500 wxWindow *result = 0 ;
23501 void *argp1 = 0 ;
23502 int res1 = 0 ;
23503 PyObject *swig_obj[1] ;
23504
23505 if (!args) SWIG_fail;
23506 swig_obj[0] = args;
23507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23508 if (!SWIG_IsOK(res1)) {
23509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23510 }
23511 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23512 {
23513 PyThreadState* __tstate = wxPyBeginAllowThreads();
23514 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23515 wxPyEndAllowThreads(__tstate);
23516 if (PyErr_Occurred()) SWIG_fail;
23517 }
23518 {
23519 resultobj = wxPyMake_wxObject(result, (bool)0);
23520 }
23521 return resultobj;
23522 fail:
23523 return NULL;
23524 }
23525
23526
23527 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23528 PyObject *resultobj = 0;
23529 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23530 wxWindow *arg2 = (wxWindow *) 0 ;
23531 void *argp1 = 0 ;
23532 int res1 = 0 ;
23533 void *argp2 = 0 ;
23534 int res2 = 0 ;
23535 PyObject * obj0 = 0 ;
23536 PyObject * obj1 = 0 ;
23537 char * kwnames[] = {
23538 (char *) "self",(char *) "win", NULL
23539 };
23540
23541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23543 if (!SWIG_IsOK(res1)) {
23544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23545 }
23546 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23547 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23548 if (!SWIG_IsOK(res2)) {
23549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23550 }
23551 arg2 = reinterpret_cast< wxWindow * >(argp2);
23552 {
23553 PyThreadState* __tstate = wxPyBeginAllowThreads();
23554 (arg1)->SetWindow(arg2);
23555 wxPyEndAllowThreads(__tstate);
23556 if (PyErr_Occurred()) SWIG_fail;
23557 }
23558 resultobj = SWIG_Py_Void();
23559 return resultobj;
23560 fail:
23561 return NULL;
23562 }
23563
23564
23565 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23566 PyObject *obj;
23567 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23568 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23569 return SWIG_Py_Void();
23570 }
23571
23572 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23573 return SWIG_Python_InitShadowInstance(args);
23574 }
23575
23576 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23577 PyObject *resultobj = 0;
23578 wxWindow *arg1 = (wxWindow *) NULL ;
23579 wxChildFocusEvent *result = 0 ;
23580 void *argp1 = 0 ;
23581 int res1 = 0 ;
23582 PyObject * obj0 = 0 ;
23583 char * kwnames[] = {
23584 (char *) "win", NULL
23585 };
23586
23587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23588 if (obj0) {
23589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23590 if (!SWIG_IsOK(res1)) {
23591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23592 }
23593 arg1 = reinterpret_cast< wxWindow * >(argp1);
23594 }
23595 {
23596 PyThreadState* __tstate = wxPyBeginAllowThreads();
23597 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23598 wxPyEndAllowThreads(__tstate);
23599 if (PyErr_Occurred()) SWIG_fail;
23600 }
23601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23602 return resultobj;
23603 fail:
23604 return NULL;
23605 }
23606
23607
23608 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23609 PyObject *resultobj = 0;
23610 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23611 wxWindow *result = 0 ;
23612 void *argp1 = 0 ;
23613 int res1 = 0 ;
23614 PyObject *swig_obj[1] ;
23615
23616 if (!args) SWIG_fail;
23617 swig_obj[0] = args;
23618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23619 if (!SWIG_IsOK(res1)) {
23620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23621 }
23622 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23623 {
23624 PyThreadState* __tstate = wxPyBeginAllowThreads();
23625 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23626 wxPyEndAllowThreads(__tstate);
23627 if (PyErr_Occurred()) SWIG_fail;
23628 }
23629 {
23630 resultobj = wxPyMake_wxObject(result, (bool)0);
23631 }
23632 return resultobj;
23633 fail:
23634 return NULL;
23635 }
23636
23637
23638 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23639 PyObject *obj;
23640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23641 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23642 return SWIG_Py_Void();
23643 }
23644
23645 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23646 return SWIG_Python_InitShadowInstance(args);
23647 }
23648
23649 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23650 PyObject *resultobj = 0;
23651 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23652 bool arg2 = (bool) true ;
23653 int arg3 = (int) 0 ;
23654 wxActivateEvent *result = 0 ;
23655 int val1 ;
23656 int ecode1 = 0 ;
23657 bool val2 ;
23658 int ecode2 = 0 ;
23659 int val3 ;
23660 int ecode3 = 0 ;
23661 PyObject * obj0 = 0 ;
23662 PyObject * obj1 = 0 ;
23663 PyObject * obj2 = 0 ;
23664 char * kwnames[] = {
23665 (char *) "type",(char *) "active",(char *) "Id", NULL
23666 };
23667
23668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23669 if (obj0) {
23670 ecode1 = SWIG_AsVal_int(obj0, &val1);
23671 if (!SWIG_IsOK(ecode1)) {
23672 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23673 }
23674 arg1 = static_cast< wxEventType >(val1);
23675 }
23676 if (obj1) {
23677 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23678 if (!SWIG_IsOK(ecode2)) {
23679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23680 }
23681 arg2 = static_cast< bool >(val2);
23682 }
23683 if (obj2) {
23684 ecode3 = SWIG_AsVal_int(obj2, &val3);
23685 if (!SWIG_IsOK(ecode3)) {
23686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23687 }
23688 arg3 = static_cast< int >(val3);
23689 }
23690 {
23691 PyThreadState* __tstate = wxPyBeginAllowThreads();
23692 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23693 wxPyEndAllowThreads(__tstate);
23694 if (PyErr_Occurred()) SWIG_fail;
23695 }
23696 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23697 return resultobj;
23698 fail:
23699 return NULL;
23700 }
23701
23702
23703 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23704 PyObject *resultobj = 0;
23705 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23706 bool result;
23707 void *argp1 = 0 ;
23708 int res1 = 0 ;
23709 PyObject *swig_obj[1] ;
23710
23711 if (!args) SWIG_fail;
23712 swig_obj[0] = args;
23713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23714 if (!SWIG_IsOK(res1)) {
23715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23716 }
23717 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23718 {
23719 PyThreadState* __tstate = wxPyBeginAllowThreads();
23720 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23721 wxPyEndAllowThreads(__tstate);
23722 if (PyErr_Occurred()) SWIG_fail;
23723 }
23724 {
23725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23726 }
23727 return resultobj;
23728 fail:
23729 return NULL;
23730 }
23731
23732
23733 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23734 PyObject *obj;
23735 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23736 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23737 return SWIG_Py_Void();
23738 }
23739
23740 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23741 return SWIG_Python_InitShadowInstance(args);
23742 }
23743
23744 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23745 PyObject *resultobj = 0;
23746 int arg1 = (int) 0 ;
23747 wxInitDialogEvent *result = 0 ;
23748 int val1 ;
23749 int ecode1 = 0 ;
23750 PyObject * obj0 = 0 ;
23751 char * kwnames[] = {
23752 (char *) "Id", NULL
23753 };
23754
23755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23756 if (obj0) {
23757 ecode1 = SWIG_AsVal_int(obj0, &val1);
23758 if (!SWIG_IsOK(ecode1)) {
23759 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23760 }
23761 arg1 = static_cast< int >(val1);
23762 }
23763 {
23764 PyThreadState* __tstate = wxPyBeginAllowThreads();
23765 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23766 wxPyEndAllowThreads(__tstate);
23767 if (PyErr_Occurred()) SWIG_fail;
23768 }
23769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23770 return resultobj;
23771 fail:
23772 return NULL;
23773 }
23774
23775
23776 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23777 PyObject *obj;
23778 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23779 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23780 return SWIG_Py_Void();
23781 }
23782
23783 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23784 return SWIG_Python_InitShadowInstance(args);
23785 }
23786
23787 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23788 PyObject *resultobj = 0;
23789 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23790 int arg2 = (int) 0 ;
23791 wxMenu *arg3 = (wxMenu *) NULL ;
23792 wxMenuEvent *result = 0 ;
23793 int val1 ;
23794 int ecode1 = 0 ;
23795 int val2 ;
23796 int ecode2 = 0 ;
23797 void *argp3 = 0 ;
23798 int res3 = 0 ;
23799 PyObject * obj0 = 0 ;
23800 PyObject * obj1 = 0 ;
23801 PyObject * obj2 = 0 ;
23802 char * kwnames[] = {
23803 (char *) "type",(char *) "winid",(char *) "menu", NULL
23804 };
23805
23806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23807 if (obj0) {
23808 ecode1 = SWIG_AsVal_int(obj0, &val1);
23809 if (!SWIG_IsOK(ecode1)) {
23810 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23811 }
23812 arg1 = static_cast< wxEventType >(val1);
23813 }
23814 if (obj1) {
23815 ecode2 = SWIG_AsVal_int(obj1, &val2);
23816 if (!SWIG_IsOK(ecode2)) {
23817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23818 }
23819 arg2 = static_cast< int >(val2);
23820 }
23821 if (obj2) {
23822 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23823 if (!SWIG_IsOK(res3)) {
23824 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23825 }
23826 arg3 = reinterpret_cast< wxMenu * >(argp3);
23827 }
23828 {
23829 PyThreadState* __tstate = wxPyBeginAllowThreads();
23830 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23831 wxPyEndAllowThreads(__tstate);
23832 if (PyErr_Occurred()) SWIG_fail;
23833 }
23834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23835 return resultobj;
23836 fail:
23837 return NULL;
23838 }
23839
23840
23841 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23842 PyObject *resultobj = 0;
23843 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23844 int result;
23845 void *argp1 = 0 ;
23846 int res1 = 0 ;
23847 PyObject *swig_obj[1] ;
23848
23849 if (!args) SWIG_fail;
23850 swig_obj[0] = args;
23851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23852 if (!SWIG_IsOK(res1)) {
23853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23854 }
23855 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23856 {
23857 PyThreadState* __tstate = wxPyBeginAllowThreads();
23858 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23859 wxPyEndAllowThreads(__tstate);
23860 if (PyErr_Occurred()) SWIG_fail;
23861 }
23862 resultobj = SWIG_From_int(static_cast< int >(result));
23863 return resultobj;
23864 fail:
23865 return NULL;
23866 }
23867
23868
23869 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23870 PyObject *resultobj = 0;
23871 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23872 bool result;
23873 void *argp1 = 0 ;
23874 int res1 = 0 ;
23875 PyObject *swig_obj[1] ;
23876
23877 if (!args) SWIG_fail;
23878 swig_obj[0] = args;
23879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23880 if (!SWIG_IsOK(res1)) {
23881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23882 }
23883 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23884 {
23885 PyThreadState* __tstate = wxPyBeginAllowThreads();
23886 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23887 wxPyEndAllowThreads(__tstate);
23888 if (PyErr_Occurred()) SWIG_fail;
23889 }
23890 {
23891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23892 }
23893 return resultobj;
23894 fail:
23895 return NULL;
23896 }
23897
23898
23899 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23900 PyObject *resultobj = 0;
23901 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23902 wxMenu *result = 0 ;
23903 void *argp1 = 0 ;
23904 int res1 = 0 ;
23905 PyObject *swig_obj[1] ;
23906
23907 if (!args) SWIG_fail;
23908 swig_obj[0] = args;
23909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23910 if (!SWIG_IsOK(res1)) {
23911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23912 }
23913 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23914 {
23915 PyThreadState* __tstate = wxPyBeginAllowThreads();
23916 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
23917 wxPyEndAllowThreads(__tstate);
23918 if (PyErr_Occurred()) SWIG_fail;
23919 }
23920 {
23921 resultobj = wxPyMake_wxObject(result, (bool)0);
23922 }
23923 return resultobj;
23924 fail:
23925 return NULL;
23926 }
23927
23928
23929 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23930 PyObject *obj;
23931 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23932 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
23933 return SWIG_Py_Void();
23934 }
23935
23936 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23937 return SWIG_Python_InitShadowInstance(args);
23938 }
23939
23940 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23941 PyObject *resultobj = 0;
23942 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23943 int arg2 = (int) 0 ;
23944 wxCloseEvent *result = 0 ;
23945 int val1 ;
23946 int ecode1 = 0 ;
23947 int val2 ;
23948 int ecode2 = 0 ;
23949 PyObject * obj0 = 0 ;
23950 PyObject * obj1 = 0 ;
23951 char * kwnames[] = {
23952 (char *) "type",(char *) "winid", NULL
23953 };
23954
23955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23956 if (obj0) {
23957 ecode1 = SWIG_AsVal_int(obj0, &val1);
23958 if (!SWIG_IsOK(ecode1)) {
23959 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23960 }
23961 arg1 = static_cast< wxEventType >(val1);
23962 }
23963 if (obj1) {
23964 ecode2 = SWIG_AsVal_int(obj1, &val2);
23965 if (!SWIG_IsOK(ecode2)) {
23966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
23967 }
23968 arg2 = static_cast< int >(val2);
23969 }
23970 {
23971 PyThreadState* __tstate = wxPyBeginAllowThreads();
23972 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
23973 wxPyEndAllowThreads(__tstate);
23974 if (PyErr_Occurred()) SWIG_fail;
23975 }
23976 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
23977 return resultobj;
23978 fail:
23979 return NULL;
23980 }
23981
23982
23983 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23984 PyObject *resultobj = 0;
23985 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
23986 bool arg2 ;
23987 void *argp1 = 0 ;
23988 int res1 = 0 ;
23989 bool val2 ;
23990 int ecode2 = 0 ;
23991 PyObject * obj0 = 0 ;
23992 PyObject * obj1 = 0 ;
23993 char * kwnames[] = {
23994 (char *) "self",(char *) "logOff", NULL
23995 };
23996
23997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
23998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
23999 if (!SWIG_IsOK(res1)) {
24000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24001 }
24002 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24003 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24004 if (!SWIG_IsOK(ecode2)) {
24005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24006 }
24007 arg2 = static_cast< bool >(val2);
24008 {
24009 PyThreadState* __tstate = wxPyBeginAllowThreads();
24010 (arg1)->SetLoggingOff(arg2);
24011 wxPyEndAllowThreads(__tstate);
24012 if (PyErr_Occurred()) SWIG_fail;
24013 }
24014 resultobj = SWIG_Py_Void();
24015 return resultobj;
24016 fail:
24017 return NULL;
24018 }
24019
24020
24021 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24022 PyObject *resultobj = 0;
24023 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24024 bool result;
24025 void *argp1 = 0 ;
24026 int res1 = 0 ;
24027 PyObject *swig_obj[1] ;
24028
24029 if (!args) SWIG_fail;
24030 swig_obj[0] = args;
24031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24032 if (!SWIG_IsOK(res1)) {
24033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24034 }
24035 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24036 {
24037 PyThreadState* __tstate = wxPyBeginAllowThreads();
24038 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24039 wxPyEndAllowThreads(__tstate);
24040 if (PyErr_Occurred()) SWIG_fail;
24041 }
24042 {
24043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24044 }
24045 return resultobj;
24046 fail:
24047 return NULL;
24048 }
24049
24050
24051 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24052 PyObject *resultobj = 0;
24053 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24054 bool arg2 = (bool) true ;
24055 void *argp1 = 0 ;
24056 int res1 = 0 ;
24057 bool val2 ;
24058 int ecode2 = 0 ;
24059 PyObject * obj0 = 0 ;
24060 PyObject * obj1 = 0 ;
24061 char * kwnames[] = {
24062 (char *) "self",(char *) "veto", NULL
24063 };
24064
24065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24067 if (!SWIG_IsOK(res1)) {
24068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24069 }
24070 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24071 if (obj1) {
24072 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24073 if (!SWIG_IsOK(ecode2)) {
24074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24075 }
24076 arg2 = static_cast< bool >(val2);
24077 }
24078 {
24079 PyThreadState* __tstate = wxPyBeginAllowThreads();
24080 (arg1)->Veto(arg2);
24081 wxPyEndAllowThreads(__tstate);
24082 if (PyErr_Occurred()) SWIG_fail;
24083 }
24084 resultobj = SWIG_Py_Void();
24085 return resultobj;
24086 fail:
24087 return NULL;
24088 }
24089
24090
24091 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24092 PyObject *resultobj = 0;
24093 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24094 bool result;
24095 void *argp1 = 0 ;
24096 int res1 = 0 ;
24097 PyObject *swig_obj[1] ;
24098
24099 if (!args) SWIG_fail;
24100 swig_obj[0] = args;
24101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24102 if (!SWIG_IsOK(res1)) {
24103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24104 }
24105 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24106 {
24107 PyThreadState* __tstate = wxPyBeginAllowThreads();
24108 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24109 wxPyEndAllowThreads(__tstate);
24110 if (PyErr_Occurred()) SWIG_fail;
24111 }
24112 {
24113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24114 }
24115 return resultobj;
24116 fail:
24117 return NULL;
24118 }
24119
24120
24121 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24122 PyObject *resultobj = 0;
24123 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24124 bool arg2 ;
24125 void *argp1 = 0 ;
24126 int res1 = 0 ;
24127 bool val2 ;
24128 int ecode2 = 0 ;
24129 PyObject * obj0 = 0 ;
24130 PyObject * obj1 = 0 ;
24131 char * kwnames[] = {
24132 (char *) "self",(char *) "canVeto", NULL
24133 };
24134
24135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24137 if (!SWIG_IsOK(res1)) {
24138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24139 }
24140 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24141 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24142 if (!SWIG_IsOK(ecode2)) {
24143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24144 }
24145 arg2 = static_cast< bool >(val2);
24146 {
24147 PyThreadState* __tstate = wxPyBeginAllowThreads();
24148 (arg1)->SetCanVeto(arg2);
24149 wxPyEndAllowThreads(__tstate);
24150 if (PyErr_Occurred()) SWIG_fail;
24151 }
24152 resultobj = SWIG_Py_Void();
24153 return resultobj;
24154 fail:
24155 return NULL;
24156 }
24157
24158
24159 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24160 PyObject *resultobj = 0;
24161 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24162 bool result;
24163 void *argp1 = 0 ;
24164 int res1 = 0 ;
24165 PyObject *swig_obj[1] ;
24166
24167 if (!args) SWIG_fail;
24168 swig_obj[0] = args;
24169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24170 if (!SWIG_IsOK(res1)) {
24171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24172 }
24173 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24174 {
24175 PyThreadState* __tstate = wxPyBeginAllowThreads();
24176 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24177 wxPyEndAllowThreads(__tstate);
24178 if (PyErr_Occurred()) SWIG_fail;
24179 }
24180 {
24181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24182 }
24183 return resultobj;
24184 fail:
24185 return NULL;
24186 }
24187
24188
24189 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24190 PyObject *obj;
24191 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24192 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24193 return SWIG_Py_Void();
24194 }
24195
24196 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24197 return SWIG_Python_InitShadowInstance(args);
24198 }
24199
24200 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24201 PyObject *resultobj = 0;
24202 int arg1 = (int) 0 ;
24203 bool arg2 = (bool) false ;
24204 wxShowEvent *result = 0 ;
24205 int val1 ;
24206 int ecode1 = 0 ;
24207 bool val2 ;
24208 int ecode2 = 0 ;
24209 PyObject * obj0 = 0 ;
24210 PyObject * obj1 = 0 ;
24211 char * kwnames[] = {
24212 (char *) "winid",(char *) "show", NULL
24213 };
24214
24215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24216 if (obj0) {
24217 ecode1 = SWIG_AsVal_int(obj0, &val1);
24218 if (!SWIG_IsOK(ecode1)) {
24219 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24220 }
24221 arg1 = static_cast< int >(val1);
24222 }
24223 if (obj1) {
24224 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24225 if (!SWIG_IsOK(ecode2)) {
24226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24227 }
24228 arg2 = static_cast< bool >(val2);
24229 }
24230 {
24231 PyThreadState* __tstate = wxPyBeginAllowThreads();
24232 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24233 wxPyEndAllowThreads(__tstate);
24234 if (PyErr_Occurred()) SWIG_fail;
24235 }
24236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24237 return resultobj;
24238 fail:
24239 return NULL;
24240 }
24241
24242
24243 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24244 PyObject *resultobj = 0;
24245 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24246 bool arg2 ;
24247 void *argp1 = 0 ;
24248 int res1 = 0 ;
24249 bool val2 ;
24250 int ecode2 = 0 ;
24251 PyObject * obj0 = 0 ;
24252 PyObject * obj1 = 0 ;
24253 char * kwnames[] = {
24254 (char *) "self",(char *) "show", NULL
24255 };
24256
24257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24259 if (!SWIG_IsOK(res1)) {
24260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24261 }
24262 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24263 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24264 if (!SWIG_IsOK(ecode2)) {
24265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24266 }
24267 arg2 = static_cast< bool >(val2);
24268 {
24269 PyThreadState* __tstate = wxPyBeginAllowThreads();
24270 (arg1)->SetShow(arg2);
24271 wxPyEndAllowThreads(__tstate);
24272 if (PyErr_Occurred()) SWIG_fail;
24273 }
24274 resultobj = SWIG_Py_Void();
24275 return resultobj;
24276 fail:
24277 return NULL;
24278 }
24279
24280
24281 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24282 PyObject *resultobj = 0;
24283 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24284 bool result;
24285 void *argp1 = 0 ;
24286 int res1 = 0 ;
24287 PyObject *swig_obj[1] ;
24288
24289 if (!args) SWIG_fail;
24290 swig_obj[0] = args;
24291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24292 if (!SWIG_IsOK(res1)) {
24293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24294 }
24295 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24296 {
24297 PyThreadState* __tstate = wxPyBeginAllowThreads();
24298 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24299 wxPyEndAllowThreads(__tstate);
24300 if (PyErr_Occurred()) SWIG_fail;
24301 }
24302 {
24303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24304 }
24305 return resultobj;
24306 fail:
24307 return NULL;
24308 }
24309
24310
24311 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24312 PyObject *obj;
24313 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24314 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24315 return SWIG_Py_Void();
24316 }
24317
24318 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24319 return SWIG_Python_InitShadowInstance(args);
24320 }
24321
24322 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24323 PyObject *resultobj = 0;
24324 int arg1 = (int) 0 ;
24325 bool arg2 = (bool) true ;
24326 wxIconizeEvent *result = 0 ;
24327 int val1 ;
24328 int ecode1 = 0 ;
24329 bool val2 ;
24330 int ecode2 = 0 ;
24331 PyObject * obj0 = 0 ;
24332 PyObject * obj1 = 0 ;
24333 char * kwnames[] = {
24334 (char *) "id",(char *) "iconized", NULL
24335 };
24336
24337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24338 if (obj0) {
24339 ecode1 = SWIG_AsVal_int(obj0, &val1);
24340 if (!SWIG_IsOK(ecode1)) {
24341 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24342 }
24343 arg1 = static_cast< int >(val1);
24344 }
24345 if (obj1) {
24346 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24347 if (!SWIG_IsOK(ecode2)) {
24348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24349 }
24350 arg2 = static_cast< bool >(val2);
24351 }
24352 {
24353 PyThreadState* __tstate = wxPyBeginAllowThreads();
24354 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24355 wxPyEndAllowThreads(__tstate);
24356 if (PyErr_Occurred()) SWIG_fail;
24357 }
24358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24359 return resultobj;
24360 fail:
24361 return NULL;
24362 }
24363
24364
24365 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24366 PyObject *resultobj = 0;
24367 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24368 bool result;
24369 void *argp1 = 0 ;
24370 int res1 = 0 ;
24371 PyObject *swig_obj[1] ;
24372
24373 if (!args) SWIG_fail;
24374 swig_obj[0] = args;
24375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24376 if (!SWIG_IsOK(res1)) {
24377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24378 }
24379 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24380 {
24381 PyThreadState* __tstate = wxPyBeginAllowThreads();
24382 result = (bool)(arg1)->Iconized();
24383 wxPyEndAllowThreads(__tstate);
24384 if (PyErr_Occurred()) SWIG_fail;
24385 }
24386 {
24387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24388 }
24389 return resultobj;
24390 fail:
24391 return NULL;
24392 }
24393
24394
24395 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24396 PyObject *obj;
24397 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24398 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24399 return SWIG_Py_Void();
24400 }
24401
24402 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24403 return SWIG_Python_InitShadowInstance(args);
24404 }
24405
24406 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24407 PyObject *resultobj = 0;
24408 int arg1 = (int) 0 ;
24409 wxMaximizeEvent *result = 0 ;
24410 int val1 ;
24411 int ecode1 = 0 ;
24412 PyObject * obj0 = 0 ;
24413 char * kwnames[] = {
24414 (char *) "id", NULL
24415 };
24416
24417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24418 if (obj0) {
24419 ecode1 = SWIG_AsVal_int(obj0, &val1);
24420 if (!SWIG_IsOK(ecode1)) {
24421 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24422 }
24423 arg1 = static_cast< int >(val1);
24424 }
24425 {
24426 PyThreadState* __tstate = wxPyBeginAllowThreads();
24427 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24428 wxPyEndAllowThreads(__tstate);
24429 if (PyErr_Occurred()) SWIG_fail;
24430 }
24431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24432 return resultobj;
24433 fail:
24434 return NULL;
24435 }
24436
24437
24438 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24439 PyObject *obj;
24440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24441 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24442 return SWIG_Py_Void();
24443 }
24444
24445 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24446 return SWIG_Python_InitShadowInstance(args);
24447 }
24448
24449 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24450 PyObject *resultobj = 0;
24451 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24452 wxPoint result;
24453 void *argp1 = 0 ;
24454 int res1 = 0 ;
24455 PyObject *swig_obj[1] ;
24456
24457 if (!args) SWIG_fail;
24458 swig_obj[0] = args;
24459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24460 if (!SWIG_IsOK(res1)) {
24461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24462 }
24463 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24464 {
24465 PyThreadState* __tstate = wxPyBeginAllowThreads();
24466 result = (arg1)->GetPosition();
24467 wxPyEndAllowThreads(__tstate);
24468 if (PyErr_Occurred()) SWIG_fail;
24469 }
24470 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24471 return resultobj;
24472 fail:
24473 return NULL;
24474 }
24475
24476
24477 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24478 PyObject *resultobj = 0;
24479 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24480 int result;
24481 void *argp1 = 0 ;
24482 int res1 = 0 ;
24483 PyObject *swig_obj[1] ;
24484
24485 if (!args) SWIG_fail;
24486 swig_obj[0] = args;
24487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24488 if (!SWIG_IsOK(res1)) {
24489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24490 }
24491 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24492 {
24493 PyThreadState* __tstate = wxPyBeginAllowThreads();
24494 result = (int)(arg1)->GetNumberOfFiles();
24495 wxPyEndAllowThreads(__tstate);
24496 if (PyErr_Occurred()) SWIG_fail;
24497 }
24498 resultobj = SWIG_From_int(static_cast< int >(result));
24499 return resultobj;
24500 fail:
24501 return NULL;
24502 }
24503
24504
24505 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24506 PyObject *resultobj = 0;
24507 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24508 PyObject *result = 0 ;
24509 void *argp1 = 0 ;
24510 int res1 = 0 ;
24511 PyObject *swig_obj[1] ;
24512
24513 if (!args) SWIG_fail;
24514 swig_obj[0] = args;
24515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24516 if (!SWIG_IsOK(res1)) {
24517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24518 }
24519 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24520 {
24521 PyThreadState* __tstate = wxPyBeginAllowThreads();
24522 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24523 wxPyEndAllowThreads(__tstate);
24524 if (PyErr_Occurred()) SWIG_fail;
24525 }
24526 resultobj = result;
24527 return resultobj;
24528 fail:
24529 return NULL;
24530 }
24531
24532
24533 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24534 PyObject *obj;
24535 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24536 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24537 return SWIG_Py_Void();
24538 }
24539
24540 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24541 PyObject *resultobj = 0;
24542 int arg1 = (int) 0 ;
24543 wxUpdateUIEvent *result = 0 ;
24544 int val1 ;
24545 int ecode1 = 0 ;
24546 PyObject * obj0 = 0 ;
24547 char * kwnames[] = {
24548 (char *) "commandId", NULL
24549 };
24550
24551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24552 if (obj0) {
24553 ecode1 = SWIG_AsVal_int(obj0, &val1);
24554 if (!SWIG_IsOK(ecode1)) {
24555 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24556 }
24557 arg1 = static_cast< int >(val1);
24558 }
24559 {
24560 PyThreadState* __tstate = wxPyBeginAllowThreads();
24561 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24562 wxPyEndAllowThreads(__tstate);
24563 if (PyErr_Occurred()) SWIG_fail;
24564 }
24565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24566 return resultobj;
24567 fail:
24568 return NULL;
24569 }
24570
24571
24572 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24573 PyObject *resultobj = 0;
24574 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24575 bool result;
24576 void *argp1 = 0 ;
24577 int res1 = 0 ;
24578 PyObject *swig_obj[1] ;
24579
24580 if (!args) SWIG_fail;
24581 swig_obj[0] = args;
24582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24583 if (!SWIG_IsOK(res1)) {
24584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24585 }
24586 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24587 {
24588 PyThreadState* __tstate = wxPyBeginAllowThreads();
24589 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24590 wxPyEndAllowThreads(__tstate);
24591 if (PyErr_Occurred()) SWIG_fail;
24592 }
24593 {
24594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24595 }
24596 return resultobj;
24597 fail:
24598 return NULL;
24599 }
24600
24601
24602 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24603 PyObject *resultobj = 0;
24604 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24605 bool result;
24606 void *argp1 = 0 ;
24607 int res1 = 0 ;
24608 PyObject *swig_obj[1] ;
24609
24610 if (!args) SWIG_fail;
24611 swig_obj[0] = args;
24612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24613 if (!SWIG_IsOK(res1)) {
24614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24615 }
24616 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24617 {
24618 PyThreadState* __tstate = wxPyBeginAllowThreads();
24619 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24620 wxPyEndAllowThreads(__tstate);
24621 if (PyErr_Occurred()) SWIG_fail;
24622 }
24623 {
24624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24625 }
24626 return resultobj;
24627 fail:
24628 return NULL;
24629 }
24630
24631
24632 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24633 PyObject *resultobj = 0;
24634 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24635 bool result;
24636 void *argp1 = 0 ;
24637 int res1 = 0 ;
24638 PyObject *swig_obj[1] ;
24639
24640 if (!args) SWIG_fail;
24641 swig_obj[0] = args;
24642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24643 if (!SWIG_IsOK(res1)) {
24644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24645 }
24646 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24647 {
24648 PyThreadState* __tstate = wxPyBeginAllowThreads();
24649 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24650 wxPyEndAllowThreads(__tstate);
24651 if (PyErr_Occurred()) SWIG_fail;
24652 }
24653 {
24654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24655 }
24656 return resultobj;
24657 fail:
24658 return NULL;
24659 }
24660
24661
24662 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24663 PyObject *resultobj = 0;
24664 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24665 wxString result;
24666 void *argp1 = 0 ;
24667 int res1 = 0 ;
24668 PyObject *swig_obj[1] ;
24669
24670 if (!args) SWIG_fail;
24671 swig_obj[0] = args;
24672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24673 if (!SWIG_IsOK(res1)) {
24674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24675 }
24676 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24677 {
24678 PyThreadState* __tstate = wxPyBeginAllowThreads();
24679 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24680 wxPyEndAllowThreads(__tstate);
24681 if (PyErr_Occurred()) SWIG_fail;
24682 }
24683 {
24684 #if wxUSE_UNICODE
24685 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24686 #else
24687 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24688 #endif
24689 }
24690 return resultobj;
24691 fail:
24692 return NULL;
24693 }
24694
24695
24696 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24697 PyObject *resultobj = 0;
24698 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24699 bool result;
24700 void *argp1 = 0 ;
24701 int res1 = 0 ;
24702 PyObject *swig_obj[1] ;
24703
24704 if (!args) SWIG_fail;
24705 swig_obj[0] = args;
24706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24707 if (!SWIG_IsOK(res1)) {
24708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24709 }
24710 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24711 {
24712 PyThreadState* __tstate = wxPyBeginAllowThreads();
24713 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24714 wxPyEndAllowThreads(__tstate);
24715 if (PyErr_Occurred()) SWIG_fail;
24716 }
24717 {
24718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24719 }
24720 return resultobj;
24721 fail:
24722 return NULL;
24723 }
24724
24725
24726 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24727 PyObject *resultobj = 0;
24728 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24729 bool result;
24730 void *argp1 = 0 ;
24731 int res1 = 0 ;
24732 PyObject *swig_obj[1] ;
24733
24734 if (!args) SWIG_fail;
24735 swig_obj[0] = args;
24736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24737 if (!SWIG_IsOK(res1)) {
24738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24739 }
24740 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24741 {
24742 PyThreadState* __tstate = wxPyBeginAllowThreads();
24743 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24744 wxPyEndAllowThreads(__tstate);
24745 if (PyErr_Occurred()) SWIG_fail;
24746 }
24747 {
24748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24749 }
24750 return resultobj;
24751 fail:
24752 return NULL;
24753 }
24754
24755
24756 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24757 PyObject *resultobj = 0;
24758 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24759 bool result;
24760 void *argp1 = 0 ;
24761 int res1 = 0 ;
24762 PyObject *swig_obj[1] ;
24763
24764 if (!args) SWIG_fail;
24765 swig_obj[0] = args;
24766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24767 if (!SWIG_IsOK(res1)) {
24768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24769 }
24770 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24771 {
24772 PyThreadState* __tstate = wxPyBeginAllowThreads();
24773 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24774 wxPyEndAllowThreads(__tstate);
24775 if (PyErr_Occurred()) SWIG_fail;
24776 }
24777 {
24778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24779 }
24780 return resultobj;
24781 fail:
24782 return NULL;
24783 }
24784
24785
24786 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24787 PyObject *resultobj = 0;
24788 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24789 bool result;
24790 void *argp1 = 0 ;
24791 int res1 = 0 ;
24792 PyObject *swig_obj[1] ;
24793
24794 if (!args) SWIG_fail;
24795 swig_obj[0] = args;
24796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24797 if (!SWIG_IsOK(res1)) {
24798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24799 }
24800 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24801 {
24802 PyThreadState* __tstate = wxPyBeginAllowThreads();
24803 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24804 wxPyEndAllowThreads(__tstate);
24805 if (PyErr_Occurred()) SWIG_fail;
24806 }
24807 {
24808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24809 }
24810 return resultobj;
24811 fail:
24812 return NULL;
24813 }
24814
24815
24816 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24817 PyObject *resultobj = 0;
24818 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24819 bool arg2 ;
24820 void *argp1 = 0 ;
24821 int res1 = 0 ;
24822 bool val2 ;
24823 int ecode2 = 0 ;
24824 PyObject * obj0 = 0 ;
24825 PyObject * obj1 = 0 ;
24826 char * kwnames[] = {
24827 (char *) "self",(char *) "check", NULL
24828 };
24829
24830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24832 if (!SWIG_IsOK(res1)) {
24833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24834 }
24835 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24836 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24837 if (!SWIG_IsOK(ecode2)) {
24838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24839 }
24840 arg2 = static_cast< bool >(val2);
24841 {
24842 PyThreadState* __tstate = wxPyBeginAllowThreads();
24843 (arg1)->Check(arg2);
24844 wxPyEndAllowThreads(__tstate);
24845 if (PyErr_Occurred()) SWIG_fail;
24846 }
24847 resultobj = SWIG_Py_Void();
24848 return resultobj;
24849 fail:
24850 return NULL;
24851 }
24852
24853
24854 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24855 PyObject *resultobj = 0;
24856 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24857 bool arg2 ;
24858 void *argp1 = 0 ;
24859 int res1 = 0 ;
24860 bool val2 ;
24861 int ecode2 = 0 ;
24862 PyObject * obj0 = 0 ;
24863 PyObject * obj1 = 0 ;
24864 char * kwnames[] = {
24865 (char *) "self",(char *) "enable", NULL
24866 };
24867
24868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24870 if (!SWIG_IsOK(res1)) {
24871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24872 }
24873 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24874 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24875 if (!SWIG_IsOK(ecode2)) {
24876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24877 }
24878 arg2 = static_cast< bool >(val2);
24879 {
24880 PyThreadState* __tstate = wxPyBeginAllowThreads();
24881 (arg1)->Enable(arg2);
24882 wxPyEndAllowThreads(__tstate);
24883 if (PyErr_Occurred()) SWIG_fail;
24884 }
24885 resultobj = SWIG_Py_Void();
24886 return resultobj;
24887 fail:
24888 return NULL;
24889 }
24890
24891
24892 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24893 PyObject *resultobj = 0;
24894 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24895 bool arg2 ;
24896 void *argp1 = 0 ;
24897 int res1 = 0 ;
24898 bool val2 ;
24899 int ecode2 = 0 ;
24900 PyObject * obj0 = 0 ;
24901 PyObject * obj1 = 0 ;
24902 char * kwnames[] = {
24903 (char *) "self",(char *) "show", NULL
24904 };
24905
24906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
24907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24908 if (!SWIG_IsOK(res1)) {
24909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24910 }
24911 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24912 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24913 if (!SWIG_IsOK(ecode2)) {
24914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
24915 }
24916 arg2 = static_cast< bool >(val2);
24917 {
24918 PyThreadState* __tstate = wxPyBeginAllowThreads();
24919 (arg1)->Show(arg2);
24920 wxPyEndAllowThreads(__tstate);
24921 if (PyErr_Occurred()) SWIG_fail;
24922 }
24923 resultobj = SWIG_Py_Void();
24924 return resultobj;
24925 fail:
24926 return NULL;
24927 }
24928
24929
24930 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24931 PyObject *resultobj = 0;
24932 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24933 wxString *arg2 = 0 ;
24934 void *argp1 = 0 ;
24935 int res1 = 0 ;
24936 bool temp2 = false ;
24937 PyObject * obj0 = 0 ;
24938 PyObject * obj1 = 0 ;
24939 char * kwnames[] = {
24940 (char *) "self",(char *) "text", NULL
24941 };
24942
24943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
24944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24945 if (!SWIG_IsOK(res1)) {
24946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24947 }
24948 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24949 {
24950 arg2 = wxString_in_helper(obj1);
24951 if (arg2 == NULL) SWIG_fail;
24952 temp2 = true;
24953 }
24954 {
24955 PyThreadState* __tstate = wxPyBeginAllowThreads();
24956 (arg1)->SetText((wxString const &)*arg2);
24957 wxPyEndAllowThreads(__tstate);
24958 if (PyErr_Occurred()) SWIG_fail;
24959 }
24960 resultobj = SWIG_Py_Void();
24961 {
24962 if (temp2)
24963 delete arg2;
24964 }
24965 return resultobj;
24966 fail:
24967 {
24968 if (temp2)
24969 delete arg2;
24970 }
24971 return NULL;
24972 }
24973
24974
24975 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24976 PyObject *resultobj = 0;
24977 long arg1 ;
24978 long val1 ;
24979 int ecode1 = 0 ;
24980 PyObject * obj0 = 0 ;
24981 char * kwnames[] = {
24982 (char *) "updateInterval", NULL
24983 };
24984
24985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
24986 ecode1 = SWIG_AsVal_long(obj0, &val1);
24987 if (!SWIG_IsOK(ecode1)) {
24988 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
24989 }
24990 arg1 = static_cast< long >(val1);
24991 {
24992 PyThreadState* __tstate = wxPyBeginAllowThreads();
24993 wxUpdateUIEvent::SetUpdateInterval(arg1);
24994 wxPyEndAllowThreads(__tstate);
24995 if (PyErr_Occurred()) SWIG_fail;
24996 }
24997 resultobj = SWIG_Py_Void();
24998 return resultobj;
24999 fail:
25000 return NULL;
25001 }
25002
25003
25004 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25005 PyObject *resultobj = 0;
25006 long result;
25007
25008 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25009 {
25010 PyThreadState* __tstate = wxPyBeginAllowThreads();
25011 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25012 wxPyEndAllowThreads(__tstate);
25013 if (PyErr_Occurred()) SWIG_fail;
25014 }
25015 resultobj = SWIG_From_long(static_cast< long >(result));
25016 return resultobj;
25017 fail:
25018 return NULL;
25019 }
25020
25021
25022 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25023 PyObject *resultobj = 0;
25024 wxWindow *arg1 = (wxWindow *) 0 ;
25025 bool result;
25026 void *argp1 = 0 ;
25027 int res1 = 0 ;
25028 PyObject * obj0 = 0 ;
25029 char * kwnames[] = {
25030 (char *) "win", NULL
25031 };
25032
25033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25035 if (!SWIG_IsOK(res1)) {
25036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25037 }
25038 arg1 = reinterpret_cast< wxWindow * >(argp1);
25039 {
25040 PyThreadState* __tstate = wxPyBeginAllowThreads();
25041 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25042 wxPyEndAllowThreads(__tstate);
25043 if (PyErr_Occurred()) SWIG_fail;
25044 }
25045 {
25046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25047 }
25048 return resultobj;
25049 fail:
25050 return NULL;
25051 }
25052
25053
25054 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25055 PyObject *resultobj = 0;
25056
25057 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25058 {
25059 PyThreadState* __tstate = wxPyBeginAllowThreads();
25060 wxUpdateUIEvent::ResetUpdateTime();
25061 wxPyEndAllowThreads(__tstate);
25062 if (PyErr_Occurred()) SWIG_fail;
25063 }
25064 resultobj = SWIG_Py_Void();
25065 return resultobj;
25066 fail:
25067 return NULL;
25068 }
25069
25070
25071 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25072 PyObject *resultobj = 0;
25073 wxUpdateUIMode arg1 ;
25074 int val1 ;
25075 int ecode1 = 0 ;
25076 PyObject * obj0 = 0 ;
25077 char * kwnames[] = {
25078 (char *) "mode", NULL
25079 };
25080
25081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25082 ecode1 = SWIG_AsVal_int(obj0, &val1);
25083 if (!SWIG_IsOK(ecode1)) {
25084 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25085 }
25086 arg1 = static_cast< wxUpdateUIMode >(val1);
25087 {
25088 PyThreadState* __tstate = wxPyBeginAllowThreads();
25089 wxUpdateUIEvent::SetMode(arg1);
25090 wxPyEndAllowThreads(__tstate);
25091 if (PyErr_Occurred()) SWIG_fail;
25092 }
25093 resultobj = SWIG_Py_Void();
25094 return resultobj;
25095 fail:
25096 return NULL;
25097 }
25098
25099
25100 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25101 PyObject *resultobj = 0;
25102 wxUpdateUIMode result;
25103
25104 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25105 {
25106 PyThreadState* __tstate = wxPyBeginAllowThreads();
25107 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25108 wxPyEndAllowThreads(__tstate);
25109 if (PyErr_Occurred()) SWIG_fail;
25110 }
25111 resultobj = SWIG_From_int(static_cast< int >(result));
25112 return resultobj;
25113 fail:
25114 return NULL;
25115 }
25116
25117
25118 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25119 PyObject *obj;
25120 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25121 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25122 return SWIG_Py_Void();
25123 }
25124
25125 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25126 return SWIG_Python_InitShadowInstance(args);
25127 }
25128
25129 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25130 PyObject *resultobj = 0;
25131 wxSysColourChangedEvent *result = 0 ;
25132
25133 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25134 {
25135 PyThreadState* __tstate = wxPyBeginAllowThreads();
25136 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25137 wxPyEndAllowThreads(__tstate);
25138 if (PyErr_Occurred()) SWIG_fail;
25139 }
25140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25141 return resultobj;
25142 fail:
25143 return NULL;
25144 }
25145
25146
25147 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25148 PyObject *obj;
25149 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25150 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25151 return SWIG_Py_Void();
25152 }
25153
25154 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25155 return SWIG_Python_InitShadowInstance(args);
25156 }
25157
25158 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25159 PyObject *resultobj = 0;
25160 int arg1 = (int) 0 ;
25161 wxWindow *arg2 = (wxWindow *) NULL ;
25162 wxMouseCaptureChangedEvent *result = 0 ;
25163 int val1 ;
25164 int ecode1 = 0 ;
25165 void *argp2 = 0 ;
25166 int res2 = 0 ;
25167 PyObject * obj0 = 0 ;
25168 PyObject * obj1 = 0 ;
25169 char * kwnames[] = {
25170 (char *) "winid",(char *) "gainedCapture", NULL
25171 };
25172
25173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25174 if (obj0) {
25175 ecode1 = SWIG_AsVal_int(obj0, &val1);
25176 if (!SWIG_IsOK(ecode1)) {
25177 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25178 }
25179 arg1 = static_cast< int >(val1);
25180 }
25181 if (obj1) {
25182 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25183 if (!SWIG_IsOK(res2)) {
25184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25185 }
25186 arg2 = reinterpret_cast< wxWindow * >(argp2);
25187 }
25188 {
25189 PyThreadState* __tstate = wxPyBeginAllowThreads();
25190 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25191 wxPyEndAllowThreads(__tstate);
25192 if (PyErr_Occurred()) SWIG_fail;
25193 }
25194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25195 return resultobj;
25196 fail:
25197 return NULL;
25198 }
25199
25200
25201 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25202 PyObject *resultobj = 0;
25203 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25204 wxWindow *result = 0 ;
25205 void *argp1 = 0 ;
25206 int res1 = 0 ;
25207 PyObject *swig_obj[1] ;
25208
25209 if (!args) SWIG_fail;
25210 swig_obj[0] = args;
25211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25212 if (!SWIG_IsOK(res1)) {
25213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25214 }
25215 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25216 {
25217 PyThreadState* __tstate = wxPyBeginAllowThreads();
25218 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25219 wxPyEndAllowThreads(__tstate);
25220 if (PyErr_Occurred()) SWIG_fail;
25221 }
25222 {
25223 resultobj = wxPyMake_wxObject(result, (bool)0);
25224 }
25225 return resultobj;
25226 fail:
25227 return NULL;
25228 }
25229
25230
25231 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25232 PyObject *obj;
25233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25234 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25235 return SWIG_Py_Void();
25236 }
25237
25238 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25239 return SWIG_Python_InitShadowInstance(args);
25240 }
25241
25242 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25243 PyObject *resultobj = 0;
25244 wxDisplayChangedEvent *result = 0 ;
25245
25246 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25247 {
25248 PyThreadState* __tstate = wxPyBeginAllowThreads();
25249 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25250 wxPyEndAllowThreads(__tstate);
25251 if (PyErr_Occurred()) SWIG_fail;
25252 }
25253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25254 return resultobj;
25255 fail:
25256 return NULL;
25257 }
25258
25259
25260 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25261 PyObject *obj;
25262 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25263 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25264 return SWIG_Py_Void();
25265 }
25266
25267 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25268 return SWIG_Python_InitShadowInstance(args);
25269 }
25270
25271 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25272 PyObject *resultobj = 0;
25273 int arg1 = (int) 0 ;
25274 wxPaletteChangedEvent *result = 0 ;
25275 int val1 ;
25276 int ecode1 = 0 ;
25277 PyObject * obj0 = 0 ;
25278 char * kwnames[] = {
25279 (char *) "id", NULL
25280 };
25281
25282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25283 if (obj0) {
25284 ecode1 = SWIG_AsVal_int(obj0, &val1);
25285 if (!SWIG_IsOK(ecode1)) {
25286 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25287 }
25288 arg1 = static_cast< int >(val1);
25289 }
25290 {
25291 PyThreadState* __tstate = wxPyBeginAllowThreads();
25292 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25293 wxPyEndAllowThreads(__tstate);
25294 if (PyErr_Occurred()) SWIG_fail;
25295 }
25296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25297 return resultobj;
25298 fail:
25299 return NULL;
25300 }
25301
25302
25303 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25304 PyObject *resultobj = 0;
25305 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25306 wxWindow *arg2 = (wxWindow *) 0 ;
25307 void *argp1 = 0 ;
25308 int res1 = 0 ;
25309 void *argp2 = 0 ;
25310 int res2 = 0 ;
25311 PyObject * obj0 = 0 ;
25312 PyObject * obj1 = 0 ;
25313 char * kwnames[] = {
25314 (char *) "self",(char *) "win", NULL
25315 };
25316
25317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25319 if (!SWIG_IsOK(res1)) {
25320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25321 }
25322 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25323 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25324 if (!SWIG_IsOK(res2)) {
25325 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25326 }
25327 arg2 = reinterpret_cast< wxWindow * >(argp2);
25328 {
25329 PyThreadState* __tstate = wxPyBeginAllowThreads();
25330 (arg1)->SetChangedWindow(arg2);
25331 wxPyEndAllowThreads(__tstate);
25332 if (PyErr_Occurred()) SWIG_fail;
25333 }
25334 resultobj = SWIG_Py_Void();
25335 return resultobj;
25336 fail:
25337 return NULL;
25338 }
25339
25340
25341 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25342 PyObject *resultobj = 0;
25343 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25344 wxWindow *result = 0 ;
25345 void *argp1 = 0 ;
25346 int res1 = 0 ;
25347 PyObject *swig_obj[1] ;
25348
25349 if (!args) SWIG_fail;
25350 swig_obj[0] = args;
25351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25352 if (!SWIG_IsOK(res1)) {
25353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25354 }
25355 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25356 {
25357 PyThreadState* __tstate = wxPyBeginAllowThreads();
25358 result = (wxWindow *)(arg1)->GetChangedWindow();
25359 wxPyEndAllowThreads(__tstate);
25360 if (PyErr_Occurred()) SWIG_fail;
25361 }
25362 {
25363 resultobj = wxPyMake_wxObject(result, (bool)0);
25364 }
25365 return resultobj;
25366 fail:
25367 return NULL;
25368 }
25369
25370
25371 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25372 PyObject *obj;
25373 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25374 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25375 return SWIG_Py_Void();
25376 }
25377
25378 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25379 return SWIG_Python_InitShadowInstance(args);
25380 }
25381
25382 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25383 PyObject *resultobj = 0;
25384 int arg1 = (int) 0 ;
25385 wxQueryNewPaletteEvent *result = 0 ;
25386 int val1 ;
25387 int ecode1 = 0 ;
25388 PyObject * obj0 = 0 ;
25389 char * kwnames[] = {
25390 (char *) "winid", NULL
25391 };
25392
25393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25394 if (obj0) {
25395 ecode1 = SWIG_AsVal_int(obj0, &val1);
25396 if (!SWIG_IsOK(ecode1)) {
25397 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25398 }
25399 arg1 = static_cast< int >(val1);
25400 }
25401 {
25402 PyThreadState* __tstate = wxPyBeginAllowThreads();
25403 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25404 wxPyEndAllowThreads(__tstate);
25405 if (PyErr_Occurred()) SWIG_fail;
25406 }
25407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25408 return resultobj;
25409 fail:
25410 return NULL;
25411 }
25412
25413
25414 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25415 PyObject *resultobj = 0;
25416 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25417 bool arg2 ;
25418 void *argp1 = 0 ;
25419 int res1 = 0 ;
25420 bool val2 ;
25421 int ecode2 = 0 ;
25422 PyObject * obj0 = 0 ;
25423 PyObject * obj1 = 0 ;
25424 char * kwnames[] = {
25425 (char *) "self",(char *) "realized", NULL
25426 };
25427
25428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25430 if (!SWIG_IsOK(res1)) {
25431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25432 }
25433 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25434 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25435 if (!SWIG_IsOK(ecode2)) {
25436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25437 }
25438 arg2 = static_cast< bool >(val2);
25439 {
25440 PyThreadState* __tstate = wxPyBeginAllowThreads();
25441 (arg1)->SetPaletteRealized(arg2);
25442 wxPyEndAllowThreads(__tstate);
25443 if (PyErr_Occurred()) SWIG_fail;
25444 }
25445 resultobj = SWIG_Py_Void();
25446 return resultobj;
25447 fail:
25448 return NULL;
25449 }
25450
25451
25452 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25453 PyObject *resultobj = 0;
25454 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25455 bool result;
25456 void *argp1 = 0 ;
25457 int res1 = 0 ;
25458 PyObject *swig_obj[1] ;
25459
25460 if (!args) SWIG_fail;
25461 swig_obj[0] = args;
25462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25463 if (!SWIG_IsOK(res1)) {
25464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25465 }
25466 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25467 {
25468 PyThreadState* __tstate = wxPyBeginAllowThreads();
25469 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25470 wxPyEndAllowThreads(__tstate);
25471 if (PyErr_Occurred()) SWIG_fail;
25472 }
25473 {
25474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25475 }
25476 return resultobj;
25477 fail:
25478 return NULL;
25479 }
25480
25481
25482 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25483 PyObject *obj;
25484 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25485 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25486 return SWIG_Py_Void();
25487 }
25488
25489 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25490 return SWIG_Python_InitShadowInstance(args);
25491 }
25492
25493 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25494 PyObject *resultobj = 0;
25495 wxNavigationKeyEvent *result = 0 ;
25496
25497 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25498 {
25499 PyThreadState* __tstate = wxPyBeginAllowThreads();
25500 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25501 wxPyEndAllowThreads(__tstate);
25502 if (PyErr_Occurred()) SWIG_fail;
25503 }
25504 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25505 return resultobj;
25506 fail:
25507 return NULL;
25508 }
25509
25510
25511 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25512 PyObject *resultobj = 0;
25513 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25514 bool result;
25515 void *argp1 = 0 ;
25516 int res1 = 0 ;
25517 PyObject *swig_obj[1] ;
25518
25519 if (!args) SWIG_fail;
25520 swig_obj[0] = args;
25521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25522 if (!SWIG_IsOK(res1)) {
25523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25524 }
25525 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25526 {
25527 PyThreadState* __tstate = wxPyBeginAllowThreads();
25528 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25529 wxPyEndAllowThreads(__tstate);
25530 if (PyErr_Occurred()) SWIG_fail;
25531 }
25532 {
25533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25534 }
25535 return resultobj;
25536 fail:
25537 return NULL;
25538 }
25539
25540
25541 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25542 PyObject *resultobj = 0;
25543 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25544 bool arg2 ;
25545 void *argp1 = 0 ;
25546 int res1 = 0 ;
25547 bool val2 ;
25548 int ecode2 = 0 ;
25549 PyObject * obj0 = 0 ;
25550 PyObject * obj1 = 0 ;
25551 char * kwnames[] = {
25552 (char *) "self",(char *) "forward", NULL
25553 };
25554
25555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25557 if (!SWIG_IsOK(res1)) {
25558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25559 }
25560 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25561 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25562 if (!SWIG_IsOK(ecode2)) {
25563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25564 }
25565 arg2 = static_cast< bool >(val2);
25566 {
25567 PyThreadState* __tstate = wxPyBeginAllowThreads();
25568 (arg1)->SetDirection(arg2);
25569 wxPyEndAllowThreads(__tstate);
25570 if (PyErr_Occurred()) SWIG_fail;
25571 }
25572 resultobj = SWIG_Py_Void();
25573 return resultobj;
25574 fail:
25575 return NULL;
25576 }
25577
25578
25579 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25580 PyObject *resultobj = 0;
25581 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25582 bool result;
25583 void *argp1 = 0 ;
25584 int res1 = 0 ;
25585 PyObject *swig_obj[1] ;
25586
25587 if (!args) SWIG_fail;
25588 swig_obj[0] = args;
25589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25590 if (!SWIG_IsOK(res1)) {
25591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25592 }
25593 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25594 {
25595 PyThreadState* __tstate = wxPyBeginAllowThreads();
25596 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25597 wxPyEndAllowThreads(__tstate);
25598 if (PyErr_Occurred()) SWIG_fail;
25599 }
25600 {
25601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25602 }
25603 return resultobj;
25604 fail:
25605 return NULL;
25606 }
25607
25608
25609 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25610 PyObject *resultobj = 0;
25611 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25612 bool arg2 ;
25613 void *argp1 = 0 ;
25614 int res1 = 0 ;
25615 bool val2 ;
25616 int ecode2 = 0 ;
25617 PyObject * obj0 = 0 ;
25618 PyObject * obj1 = 0 ;
25619 char * kwnames[] = {
25620 (char *) "self",(char *) "ischange", NULL
25621 };
25622
25623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25625 if (!SWIG_IsOK(res1)) {
25626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25627 }
25628 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25629 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25630 if (!SWIG_IsOK(ecode2)) {
25631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25632 }
25633 arg2 = static_cast< bool >(val2);
25634 {
25635 PyThreadState* __tstate = wxPyBeginAllowThreads();
25636 (arg1)->SetWindowChange(arg2);
25637 wxPyEndAllowThreads(__tstate);
25638 if (PyErr_Occurred()) SWIG_fail;
25639 }
25640 resultobj = SWIG_Py_Void();
25641 return resultobj;
25642 fail:
25643 return NULL;
25644 }
25645
25646
25647 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25648 PyObject *resultobj = 0;
25649 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25650 bool result;
25651 void *argp1 = 0 ;
25652 int res1 = 0 ;
25653 PyObject *swig_obj[1] ;
25654
25655 if (!args) SWIG_fail;
25656 swig_obj[0] = args;
25657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25658 if (!SWIG_IsOK(res1)) {
25659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25660 }
25661 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25662 {
25663 PyThreadState* __tstate = wxPyBeginAllowThreads();
25664 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25665 wxPyEndAllowThreads(__tstate);
25666 if (PyErr_Occurred()) SWIG_fail;
25667 }
25668 {
25669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25670 }
25671 return resultobj;
25672 fail:
25673 return NULL;
25674 }
25675
25676
25677 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25678 PyObject *resultobj = 0;
25679 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25680 bool arg2 ;
25681 void *argp1 = 0 ;
25682 int res1 = 0 ;
25683 bool val2 ;
25684 int ecode2 = 0 ;
25685 PyObject * obj0 = 0 ;
25686 PyObject * obj1 = 0 ;
25687 char * kwnames[] = {
25688 (char *) "self",(char *) "bIs", NULL
25689 };
25690
25691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25693 if (!SWIG_IsOK(res1)) {
25694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25695 }
25696 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25697 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25698 if (!SWIG_IsOK(ecode2)) {
25699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25700 }
25701 arg2 = static_cast< bool >(val2);
25702 {
25703 PyThreadState* __tstate = wxPyBeginAllowThreads();
25704 (arg1)->SetFromTab(arg2);
25705 wxPyEndAllowThreads(__tstate);
25706 if (PyErr_Occurred()) SWIG_fail;
25707 }
25708 resultobj = SWIG_Py_Void();
25709 return resultobj;
25710 fail:
25711 return NULL;
25712 }
25713
25714
25715 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25716 PyObject *resultobj = 0;
25717 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25718 long arg2 ;
25719 void *argp1 = 0 ;
25720 int res1 = 0 ;
25721 long val2 ;
25722 int ecode2 = 0 ;
25723 PyObject * obj0 = 0 ;
25724 PyObject * obj1 = 0 ;
25725 char * kwnames[] = {
25726 (char *) "self",(char *) "flags", NULL
25727 };
25728
25729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25731 if (!SWIG_IsOK(res1)) {
25732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25733 }
25734 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25735 ecode2 = SWIG_AsVal_long(obj1, &val2);
25736 if (!SWIG_IsOK(ecode2)) {
25737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25738 }
25739 arg2 = static_cast< long >(val2);
25740 {
25741 PyThreadState* __tstate = wxPyBeginAllowThreads();
25742 (arg1)->SetFlags(arg2);
25743 wxPyEndAllowThreads(__tstate);
25744 if (PyErr_Occurred()) SWIG_fail;
25745 }
25746 resultobj = SWIG_Py_Void();
25747 return resultobj;
25748 fail:
25749 return NULL;
25750 }
25751
25752
25753 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25754 PyObject *resultobj = 0;
25755 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25756 wxWindow *result = 0 ;
25757 void *argp1 = 0 ;
25758 int res1 = 0 ;
25759 PyObject *swig_obj[1] ;
25760
25761 if (!args) SWIG_fail;
25762 swig_obj[0] = args;
25763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25764 if (!SWIG_IsOK(res1)) {
25765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25766 }
25767 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25768 {
25769 PyThreadState* __tstate = wxPyBeginAllowThreads();
25770 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25771 wxPyEndAllowThreads(__tstate);
25772 if (PyErr_Occurred()) SWIG_fail;
25773 }
25774 {
25775 resultobj = wxPyMake_wxObject(result, (bool)0);
25776 }
25777 return resultobj;
25778 fail:
25779 return NULL;
25780 }
25781
25782
25783 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25784 PyObject *resultobj = 0;
25785 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25786 wxWindow *arg2 = (wxWindow *) 0 ;
25787 void *argp1 = 0 ;
25788 int res1 = 0 ;
25789 void *argp2 = 0 ;
25790 int res2 = 0 ;
25791 PyObject * obj0 = 0 ;
25792 PyObject * obj1 = 0 ;
25793 char * kwnames[] = {
25794 (char *) "self",(char *) "win", NULL
25795 };
25796
25797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25799 if (!SWIG_IsOK(res1)) {
25800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25801 }
25802 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25803 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25804 if (!SWIG_IsOK(res2)) {
25805 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25806 }
25807 arg2 = reinterpret_cast< wxWindow * >(argp2);
25808 {
25809 PyThreadState* __tstate = wxPyBeginAllowThreads();
25810 (arg1)->SetCurrentFocus(arg2);
25811 wxPyEndAllowThreads(__tstate);
25812 if (PyErr_Occurred()) SWIG_fail;
25813 }
25814 resultobj = SWIG_Py_Void();
25815 return resultobj;
25816 fail:
25817 return NULL;
25818 }
25819
25820
25821 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25822 PyObject *obj;
25823 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25824 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25825 return SWIG_Py_Void();
25826 }
25827
25828 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25829 return SWIG_Python_InitShadowInstance(args);
25830 }
25831
25832 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25833 PyObject *resultobj = 0;
25834 wxWindow *arg1 = (wxWindow *) NULL ;
25835 wxWindowCreateEvent *result = 0 ;
25836 void *argp1 = 0 ;
25837 int res1 = 0 ;
25838 PyObject * obj0 = 0 ;
25839 char * kwnames[] = {
25840 (char *) "win", NULL
25841 };
25842
25843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25844 if (obj0) {
25845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25846 if (!SWIG_IsOK(res1)) {
25847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25848 }
25849 arg1 = reinterpret_cast< wxWindow * >(argp1);
25850 }
25851 {
25852 PyThreadState* __tstate = wxPyBeginAllowThreads();
25853 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25854 wxPyEndAllowThreads(__tstate);
25855 if (PyErr_Occurred()) SWIG_fail;
25856 }
25857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25858 return resultobj;
25859 fail:
25860 return NULL;
25861 }
25862
25863
25864 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25865 PyObject *resultobj = 0;
25866 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25867 wxWindow *result = 0 ;
25868 void *argp1 = 0 ;
25869 int res1 = 0 ;
25870 PyObject *swig_obj[1] ;
25871
25872 if (!args) SWIG_fail;
25873 swig_obj[0] = args;
25874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25875 if (!SWIG_IsOK(res1)) {
25876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25877 }
25878 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25879 {
25880 PyThreadState* __tstate = wxPyBeginAllowThreads();
25881 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25882 wxPyEndAllowThreads(__tstate);
25883 if (PyErr_Occurred()) SWIG_fail;
25884 }
25885 {
25886 resultobj = wxPyMake_wxObject(result, (bool)0);
25887 }
25888 return resultobj;
25889 fail:
25890 return NULL;
25891 }
25892
25893
25894 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25895 PyObject *obj;
25896 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25897 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25898 return SWIG_Py_Void();
25899 }
25900
25901 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25902 return SWIG_Python_InitShadowInstance(args);
25903 }
25904
25905 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25906 PyObject *resultobj = 0;
25907 wxWindow *arg1 = (wxWindow *) NULL ;
25908 wxWindowDestroyEvent *result = 0 ;
25909 void *argp1 = 0 ;
25910 int res1 = 0 ;
25911 PyObject * obj0 = 0 ;
25912 char * kwnames[] = {
25913 (char *) "win", NULL
25914 };
25915
25916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
25917 if (obj0) {
25918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25919 if (!SWIG_IsOK(res1)) {
25920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25921 }
25922 arg1 = reinterpret_cast< wxWindow * >(argp1);
25923 }
25924 {
25925 PyThreadState* __tstate = wxPyBeginAllowThreads();
25926 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
25927 wxPyEndAllowThreads(__tstate);
25928 if (PyErr_Occurred()) SWIG_fail;
25929 }
25930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
25931 return resultobj;
25932 fail:
25933 return NULL;
25934 }
25935
25936
25937 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25938 PyObject *resultobj = 0;
25939 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
25940 wxWindow *result = 0 ;
25941 void *argp1 = 0 ;
25942 int res1 = 0 ;
25943 PyObject *swig_obj[1] ;
25944
25945 if (!args) SWIG_fail;
25946 swig_obj[0] = args;
25947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
25948 if (!SWIG_IsOK(res1)) {
25949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
25950 }
25951 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
25952 {
25953 PyThreadState* __tstate = wxPyBeginAllowThreads();
25954 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
25955 wxPyEndAllowThreads(__tstate);
25956 if (PyErr_Occurred()) SWIG_fail;
25957 }
25958 {
25959 resultobj = wxPyMake_wxObject(result, (bool)0);
25960 }
25961 return resultobj;
25962 fail:
25963 return NULL;
25964 }
25965
25966
25967 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25968 PyObject *obj;
25969 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25970 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
25971 return SWIG_Py_Void();
25972 }
25973
25974 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25975 return SWIG_Python_InitShadowInstance(args);
25976 }
25977
25978 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25979 PyObject *resultobj = 0;
25980 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
25981 int arg2 = (int) 0 ;
25982 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25983 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25984 wxContextMenuEvent *result = 0 ;
25985 int val1 ;
25986 int ecode1 = 0 ;
25987 int val2 ;
25988 int ecode2 = 0 ;
25989 wxPoint temp3 ;
25990 PyObject * obj0 = 0 ;
25991 PyObject * obj1 = 0 ;
25992 PyObject * obj2 = 0 ;
25993 char * kwnames[] = {
25994 (char *) "type",(char *) "winid",(char *) "pt", NULL
25995 };
25996
25997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25998 if (obj0) {
25999 ecode1 = SWIG_AsVal_int(obj0, &val1);
26000 if (!SWIG_IsOK(ecode1)) {
26001 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26002 }
26003 arg1 = static_cast< wxEventType >(val1);
26004 }
26005 if (obj1) {
26006 ecode2 = SWIG_AsVal_int(obj1, &val2);
26007 if (!SWIG_IsOK(ecode2)) {
26008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26009 }
26010 arg2 = static_cast< int >(val2);
26011 }
26012 if (obj2) {
26013 {
26014 arg3 = &temp3;
26015 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26016 }
26017 }
26018 {
26019 PyThreadState* __tstate = wxPyBeginAllowThreads();
26020 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26021 wxPyEndAllowThreads(__tstate);
26022 if (PyErr_Occurred()) SWIG_fail;
26023 }
26024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26025 return resultobj;
26026 fail:
26027 return NULL;
26028 }
26029
26030
26031 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26032 PyObject *resultobj = 0;
26033 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26034 wxPoint *result = 0 ;
26035 void *argp1 = 0 ;
26036 int res1 = 0 ;
26037 PyObject *swig_obj[1] ;
26038
26039 if (!args) SWIG_fail;
26040 swig_obj[0] = args;
26041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26042 if (!SWIG_IsOK(res1)) {
26043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26044 }
26045 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26046 {
26047 PyThreadState* __tstate = wxPyBeginAllowThreads();
26048 {
26049 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26050 result = (wxPoint *) &_result_ref;
26051 }
26052 wxPyEndAllowThreads(__tstate);
26053 if (PyErr_Occurred()) SWIG_fail;
26054 }
26055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26056 return resultobj;
26057 fail:
26058 return NULL;
26059 }
26060
26061
26062 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26063 PyObject *resultobj = 0;
26064 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26065 wxPoint *arg2 = 0 ;
26066 void *argp1 = 0 ;
26067 int res1 = 0 ;
26068 wxPoint temp2 ;
26069 PyObject * obj0 = 0 ;
26070 PyObject * obj1 = 0 ;
26071 char * kwnames[] = {
26072 (char *) "self",(char *) "pos", NULL
26073 };
26074
26075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26077 if (!SWIG_IsOK(res1)) {
26078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26079 }
26080 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26081 {
26082 arg2 = &temp2;
26083 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26084 }
26085 {
26086 PyThreadState* __tstate = wxPyBeginAllowThreads();
26087 (arg1)->SetPosition((wxPoint const &)*arg2);
26088 wxPyEndAllowThreads(__tstate);
26089 if (PyErr_Occurred()) SWIG_fail;
26090 }
26091 resultobj = SWIG_Py_Void();
26092 return resultobj;
26093 fail:
26094 return NULL;
26095 }
26096
26097
26098 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26099 PyObject *obj;
26100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26101 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26102 return SWIG_Py_Void();
26103 }
26104
26105 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26106 return SWIG_Python_InitShadowInstance(args);
26107 }
26108
26109 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26110 PyObject *resultobj = 0;
26111 wxIdleEvent *result = 0 ;
26112
26113 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26114 {
26115 PyThreadState* __tstate = wxPyBeginAllowThreads();
26116 result = (wxIdleEvent *)new wxIdleEvent();
26117 wxPyEndAllowThreads(__tstate);
26118 if (PyErr_Occurred()) SWIG_fail;
26119 }
26120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26121 return resultobj;
26122 fail:
26123 return NULL;
26124 }
26125
26126
26127 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26128 PyObject *resultobj = 0;
26129 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26130 bool arg2 = (bool) true ;
26131 void *argp1 = 0 ;
26132 int res1 = 0 ;
26133 bool val2 ;
26134 int ecode2 = 0 ;
26135 PyObject * obj0 = 0 ;
26136 PyObject * obj1 = 0 ;
26137 char * kwnames[] = {
26138 (char *) "self",(char *) "needMore", NULL
26139 };
26140
26141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26143 if (!SWIG_IsOK(res1)) {
26144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26145 }
26146 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26147 if (obj1) {
26148 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26149 if (!SWIG_IsOK(ecode2)) {
26150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26151 }
26152 arg2 = static_cast< bool >(val2);
26153 }
26154 {
26155 PyThreadState* __tstate = wxPyBeginAllowThreads();
26156 (arg1)->RequestMore(arg2);
26157 wxPyEndAllowThreads(__tstate);
26158 if (PyErr_Occurred()) SWIG_fail;
26159 }
26160 resultobj = SWIG_Py_Void();
26161 return resultobj;
26162 fail:
26163 return NULL;
26164 }
26165
26166
26167 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26168 PyObject *resultobj = 0;
26169 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26170 bool result;
26171 void *argp1 = 0 ;
26172 int res1 = 0 ;
26173 PyObject *swig_obj[1] ;
26174
26175 if (!args) SWIG_fail;
26176 swig_obj[0] = args;
26177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26178 if (!SWIG_IsOK(res1)) {
26179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26180 }
26181 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26182 {
26183 PyThreadState* __tstate = wxPyBeginAllowThreads();
26184 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26185 wxPyEndAllowThreads(__tstate);
26186 if (PyErr_Occurred()) SWIG_fail;
26187 }
26188 {
26189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26190 }
26191 return resultobj;
26192 fail:
26193 return NULL;
26194 }
26195
26196
26197 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26198 PyObject *resultobj = 0;
26199 wxIdleMode arg1 ;
26200 int val1 ;
26201 int ecode1 = 0 ;
26202 PyObject * obj0 = 0 ;
26203 char * kwnames[] = {
26204 (char *) "mode", NULL
26205 };
26206
26207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26208 ecode1 = SWIG_AsVal_int(obj0, &val1);
26209 if (!SWIG_IsOK(ecode1)) {
26210 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26211 }
26212 arg1 = static_cast< wxIdleMode >(val1);
26213 {
26214 PyThreadState* __tstate = wxPyBeginAllowThreads();
26215 wxIdleEvent::SetMode(arg1);
26216 wxPyEndAllowThreads(__tstate);
26217 if (PyErr_Occurred()) SWIG_fail;
26218 }
26219 resultobj = SWIG_Py_Void();
26220 return resultobj;
26221 fail:
26222 return NULL;
26223 }
26224
26225
26226 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26227 PyObject *resultobj = 0;
26228 wxIdleMode result;
26229
26230 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26231 {
26232 PyThreadState* __tstate = wxPyBeginAllowThreads();
26233 result = (wxIdleMode)wxIdleEvent::GetMode();
26234 wxPyEndAllowThreads(__tstate);
26235 if (PyErr_Occurred()) SWIG_fail;
26236 }
26237 resultobj = SWIG_From_int(static_cast< int >(result));
26238 return resultobj;
26239 fail:
26240 return NULL;
26241 }
26242
26243
26244 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26245 PyObject *resultobj = 0;
26246 wxWindow *arg1 = (wxWindow *) 0 ;
26247 bool result;
26248 void *argp1 = 0 ;
26249 int res1 = 0 ;
26250 PyObject * obj0 = 0 ;
26251 char * kwnames[] = {
26252 (char *) "win", NULL
26253 };
26254
26255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26257 if (!SWIG_IsOK(res1)) {
26258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26259 }
26260 arg1 = reinterpret_cast< wxWindow * >(argp1);
26261 {
26262 PyThreadState* __tstate = wxPyBeginAllowThreads();
26263 result = (bool)wxIdleEvent::CanSend(arg1);
26264 wxPyEndAllowThreads(__tstate);
26265 if (PyErr_Occurred()) SWIG_fail;
26266 }
26267 {
26268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26269 }
26270 return resultobj;
26271 fail:
26272 return NULL;
26273 }
26274
26275
26276 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26277 PyObject *obj;
26278 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26279 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26280 return SWIG_Py_Void();
26281 }
26282
26283 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26284 return SWIG_Python_InitShadowInstance(args);
26285 }
26286
26287 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26288 PyObject *resultobj = 0;
26289 int arg1 = (int) 0 ;
26290 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26291 wxPyEvent *result = 0 ;
26292 int val1 ;
26293 int ecode1 = 0 ;
26294 int val2 ;
26295 int ecode2 = 0 ;
26296 PyObject * obj0 = 0 ;
26297 PyObject * obj1 = 0 ;
26298 char * kwnames[] = {
26299 (char *) "winid",(char *) "eventType", NULL
26300 };
26301
26302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26303 if (obj0) {
26304 ecode1 = SWIG_AsVal_int(obj0, &val1);
26305 if (!SWIG_IsOK(ecode1)) {
26306 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26307 }
26308 arg1 = static_cast< int >(val1);
26309 }
26310 if (obj1) {
26311 ecode2 = SWIG_AsVal_int(obj1, &val2);
26312 if (!SWIG_IsOK(ecode2)) {
26313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26314 }
26315 arg2 = static_cast< wxEventType >(val2);
26316 }
26317 {
26318 PyThreadState* __tstate = wxPyBeginAllowThreads();
26319 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26320 wxPyEndAllowThreads(__tstate);
26321 if (PyErr_Occurred()) SWIG_fail;
26322 }
26323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26324 return resultobj;
26325 fail:
26326 return NULL;
26327 }
26328
26329
26330 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26331 PyObject *resultobj = 0;
26332 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26333 void *argp1 = 0 ;
26334 int res1 = 0 ;
26335 PyObject *swig_obj[1] ;
26336
26337 if (!args) SWIG_fail;
26338 swig_obj[0] = args;
26339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26340 if (!SWIG_IsOK(res1)) {
26341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26342 }
26343 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26344 {
26345 PyThreadState* __tstate = wxPyBeginAllowThreads();
26346 delete arg1;
26347
26348 wxPyEndAllowThreads(__tstate);
26349 if (PyErr_Occurred()) SWIG_fail;
26350 }
26351 resultobj = SWIG_Py_Void();
26352 return resultobj;
26353 fail:
26354 return NULL;
26355 }
26356
26357
26358 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26359 PyObject *resultobj = 0;
26360 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26361 PyObject *arg2 = (PyObject *) 0 ;
26362 void *argp1 = 0 ;
26363 int res1 = 0 ;
26364 PyObject * obj0 = 0 ;
26365 PyObject * obj1 = 0 ;
26366 char * kwnames[] = {
26367 (char *) "self",(char *) "self", NULL
26368 };
26369
26370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26372 if (!SWIG_IsOK(res1)) {
26373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26374 }
26375 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26376 arg2 = obj1;
26377 {
26378 PyThreadState* __tstate = wxPyBeginAllowThreads();
26379 (arg1)->SetSelf(arg2);
26380 wxPyEndAllowThreads(__tstate);
26381 if (PyErr_Occurred()) SWIG_fail;
26382 }
26383 resultobj = SWIG_Py_Void();
26384 return resultobj;
26385 fail:
26386 return NULL;
26387 }
26388
26389
26390 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26391 PyObject *resultobj = 0;
26392 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26393 PyObject *result = 0 ;
26394 void *argp1 = 0 ;
26395 int res1 = 0 ;
26396 PyObject *swig_obj[1] ;
26397
26398 if (!args) SWIG_fail;
26399 swig_obj[0] = args;
26400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26401 if (!SWIG_IsOK(res1)) {
26402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26403 }
26404 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26405 {
26406 PyThreadState* __tstate = wxPyBeginAllowThreads();
26407 result = (PyObject *)(arg1)->GetSelf();
26408 wxPyEndAllowThreads(__tstate);
26409 if (PyErr_Occurred()) SWIG_fail;
26410 }
26411 resultobj = result;
26412 return resultobj;
26413 fail:
26414 return NULL;
26415 }
26416
26417
26418 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26419 PyObject *obj;
26420 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26421 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26422 return SWIG_Py_Void();
26423 }
26424
26425 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26426 return SWIG_Python_InitShadowInstance(args);
26427 }
26428
26429 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26430 PyObject *resultobj = 0;
26431 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26432 int arg2 = (int) 0 ;
26433 wxPyCommandEvent *result = 0 ;
26434 int val1 ;
26435 int ecode1 = 0 ;
26436 int val2 ;
26437 int ecode2 = 0 ;
26438 PyObject * obj0 = 0 ;
26439 PyObject * obj1 = 0 ;
26440 char * kwnames[] = {
26441 (char *) "eventType",(char *) "id", NULL
26442 };
26443
26444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26445 if (obj0) {
26446 ecode1 = SWIG_AsVal_int(obj0, &val1);
26447 if (!SWIG_IsOK(ecode1)) {
26448 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26449 }
26450 arg1 = static_cast< wxEventType >(val1);
26451 }
26452 if (obj1) {
26453 ecode2 = SWIG_AsVal_int(obj1, &val2);
26454 if (!SWIG_IsOK(ecode2)) {
26455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26456 }
26457 arg2 = static_cast< int >(val2);
26458 }
26459 {
26460 PyThreadState* __tstate = wxPyBeginAllowThreads();
26461 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26462 wxPyEndAllowThreads(__tstate);
26463 if (PyErr_Occurred()) SWIG_fail;
26464 }
26465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26466 return resultobj;
26467 fail:
26468 return NULL;
26469 }
26470
26471
26472 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26473 PyObject *resultobj = 0;
26474 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26475 void *argp1 = 0 ;
26476 int res1 = 0 ;
26477 PyObject *swig_obj[1] ;
26478
26479 if (!args) SWIG_fail;
26480 swig_obj[0] = args;
26481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26482 if (!SWIG_IsOK(res1)) {
26483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26484 }
26485 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26486 {
26487 PyThreadState* __tstate = wxPyBeginAllowThreads();
26488 delete arg1;
26489
26490 wxPyEndAllowThreads(__tstate);
26491 if (PyErr_Occurred()) SWIG_fail;
26492 }
26493 resultobj = SWIG_Py_Void();
26494 return resultobj;
26495 fail:
26496 return NULL;
26497 }
26498
26499
26500 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26501 PyObject *resultobj = 0;
26502 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26503 PyObject *arg2 = (PyObject *) 0 ;
26504 void *argp1 = 0 ;
26505 int res1 = 0 ;
26506 PyObject * obj0 = 0 ;
26507 PyObject * obj1 = 0 ;
26508 char * kwnames[] = {
26509 (char *) "self",(char *) "self", NULL
26510 };
26511
26512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26514 if (!SWIG_IsOK(res1)) {
26515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26516 }
26517 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26518 arg2 = obj1;
26519 {
26520 PyThreadState* __tstate = wxPyBeginAllowThreads();
26521 (arg1)->SetSelf(arg2);
26522 wxPyEndAllowThreads(__tstate);
26523 if (PyErr_Occurred()) SWIG_fail;
26524 }
26525 resultobj = SWIG_Py_Void();
26526 return resultobj;
26527 fail:
26528 return NULL;
26529 }
26530
26531
26532 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26533 PyObject *resultobj = 0;
26534 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26535 PyObject *result = 0 ;
26536 void *argp1 = 0 ;
26537 int res1 = 0 ;
26538 PyObject *swig_obj[1] ;
26539
26540 if (!args) SWIG_fail;
26541 swig_obj[0] = args;
26542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26543 if (!SWIG_IsOK(res1)) {
26544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26545 }
26546 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26547 {
26548 PyThreadState* __tstate = wxPyBeginAllowThreads();
26549 result = (PyObject *)(arg1)->GetSelf();
26550 wxPyEndAllowThreads(__tstate);
26551 if (PyErr_Occurred()) SWIG_fail;
26552 }
26553 resultobj = result;
26554 return resultobj;
26555 fail:
26556 return NULL;
26557 }
26558
26559
26560 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26561 PyObject *obj;
26562 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26563 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26564 return SWIG_Py_Void();
26565 }
26566
26567 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26568 return SWIG_Python_InitShadowInstance(args);
26569 }
26570
26571 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26572 PyObject *resultobj = 0;
26573 wxWindow *arg1 = (wxWindow *) 0 ;
26574 wxDateTime *arg2 = 0 ;
26575 wxEventType arg3 ;
26576 wxDateEvent *result = 0 ;
26577 void *argp1 = 0 ;
26578 int res1 = 0 ;
26579 void *argp2 = 0 ;
26580 int res2 = 0 ;
26581 int val3 ;
26582 int ecode3 = 0 ;
26583 PyObject * obj0 = 0 ;
26584 PyObject * obj1 = 0 ;
26585 PyObject * obj2 = 0 ;
26586 char * kwnames[] = {
26587 (char *) "win",(char *) "dt",(char *) "type", NULL
26588 };
26589
26590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26592 if (!SWIG_IsOK(res1)) {
26593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26594 }
26595 arg1 = reinterpret_cast< wxWindow * >(argp1);
26596 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26597 if (!SWIG_IsOK(res2)) {
26598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26599 }
26600 if (!argp2) {
26601 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26602 }
26603 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26604 ecode3 = SWIG_AsVal_int(obj2, &val3);
26605 if (!SWIG_IsOK(ecode3)) {
26606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26607 }
26608 arg3 = static_cast< wxEventType >(val3);
26609 {
26610 PyThreadState* __tstate = wxPyBeginAllowThreads();
26611 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26612 wxPyEndAllowThreads(__tstate);
26613 if (PyErr_Occurred()) SWIG_fail;
26614 }
26615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26616 return resultobj;
26617 fail:
26618 return NULL;
26619 }
26620
26621
26622 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26623 PyObject *resultobj = 0;
26624 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26625 wxDateTime *result = 0 ;
26626 void *argp1 = 0 ;
26627 int res1 = 0 ;
26628 PyObject *swig_obj[1] ;
26629
26630 if (!args) SWIG_fail;
26631 swig_obj[0] = args;
26632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26633 if (!SWIG_IsOK(res1)) {
26634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26635 }
26636 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26637 {
26638 PyThreadState* __tstate = wxPyBeginAllowThreads();
26639 {
26640 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26641 result = (wxDateTime *) &_result_ref;
26642 }
26643 wxPyEndAllowThreads(__tstate);
26644 if (PyErr_Occurred()) SWIG_fail;
26645 }
26646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26647 return resultobj;
26648 fail:
26649 return NULL;
26650 }
26651
26652
26653 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26654 PyObject *resultobj = 0;
26655 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26656 wxDateTime *arg2 = 0 ;
26657 void *argp1 = 0 ;
26658 int res1 = 0 ;
26659 void *argp2 = 0 ;
26660 int res2 = 0 ;
26661 PyObject * obj0 = 0 ;
26662 PyObject * obj1 = 0 ;
26663 char * kwnames[] = {
26664 (char *) "self",(char *) "date", NULL
26665 };
26666
26667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26669 if (!SWIG_IsOK(res1)) {
26670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26671 }
26672 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26673 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26674 if (!SWIG_IsOK(res2)) {
26675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26676 }
26677 if (!argp2) {
26678 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26679 }
26680 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26681 {
26682 PyThreadState* __tstate = wxPyBeginAllowThreads();
26683 (arg1)->SetDate((wxDateTime const &)*arg2);
26684 wxPyEndAllowThreads(__tstate);
26685 if (PyErr_Occurred()) SWIG_fail;
26686 }
26687 resultobj = SWIG_Py_Void();
26688 return resultobj;
26689 fail:
26690 return NULL;
26691 }
26692
26693
26694 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26695 PyObject *obj;
26696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26697 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26698 return SWIG_Py_Void();
26699 }
26700
26701 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26702 return SWIG_Python_InitShadowInstance(args);
26703 }
26704
26705 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26706 PyObject *resultobj = 0;
26707 wxPyApp *result = 0 ;
26708
26709 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26710 {
26711 PyThreadState* __tstate = wxPyBeginAllowThreads();
26712 result = (wxPyApp *)new_wxPyApp();
26713 wxPyEndAllowThreads(__tstate);
26714 if (PyErr_Occurred()) SWIG_fail;
26715 }
26716 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26717 return resultobj;
26718 fail:
26719 return NULL;
26720 }
26721
26722
26723 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26724 PyObject *resultobj = 0;
26725 wxPyApp *arg1 = (wxPyApp *) 0 ;
26726 void *argp1 = 0 ;
26727 int res1 = 0 ;
26728 PyObject *swig_obj[1] ;
26729
26730 if (!args) SWIG_fail;
26731 swig_obj[0] = args;
26732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26733 if (!SWIG_IsOK(res1)) {
26734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26735 }
26736 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26737 {
26738 PyThreadState* __tstate = wxPyBeginAllowThreads();
26739 delete arg1;
26740
26741 wxPyEndAllowThreads(__tstate);
26742 if (PyErr_Occurred()) SWIG_fail;
26743 }
26744 resultobj = SWIG_Py_Void();
26745 return resultobj;
26746 fail:
26747 return NULL;
26748 }
26749
26750
26751 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26752 PyObject *resultobj = 0;
26753 wxPyApp *arg1 = (wxPyApp *) 0 ;
26754 PyObject *arg2 = (PyObject *) 0 ;
26755 PyObject *arg3 = (PyObject *) 0 ;
26756 bool arg4 ;
26757 void *argp1 = 0 ;
26758 int res1 = 0 ;
26759 bool val4 ;
26760 int ecode4 = 0 ;
26761 PyObject * obj0 = 0 ;
26762 PyObject * obj1 = 0 ;
26763 PyObject * obj2 = 0 ;
26764 PyObject * obj3 = 0 ;
26765 char * kwnames[] = {
26766 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26767 };
26768
26769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26771 if (!SWIG_IsOK(res1)) {
26772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26773 }
26774 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26775 arg2 = obj1;
26776 arg3 = obj2;
26777 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26778 if (!SWIG_IsOK(ecode4)) {
26779 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26780 }
26781 arg4 = static_cast< bool >(val4);
26782 {
26783 PyThreadState* __tstate = wxPyBeginAllowThreads();
26784 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26785 wxPyEndAllowThreads(__tstate);
26786 if (PyErr_Occurred()) SWIG_fail;
26787 }
26788 resultobj = SWIG_Py_Void();
26789 return resultobj;
26790 fail:
26791 return NULL;
26792 }
26793
26794
26795 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26796 PyObject *resultobj = 0;
26797 wxPyApp *arg1 = (wxPyApp *) 0 ;
26798 wxString result;
26799 void *argp1 = 0 ;
26800 int res1 = 0 ;
26801 PyObject *swig_obj[1] ;
26802
26803 if (!args) SWIG_fail;
26804 swig_obj[0] = args;
26805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26806 if (!SWIG_IsOK(res1)) {
26807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26808 }
26809 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26810 {
26811 PyThreadState* __tstate = wxPyBeginAllowThreads();
26812 result = ((wxPyApp const *)arg1)->GetAppName();
26813 wxPyEndAllowThreads(__tstate);
26814 if (PyErr_Occurred()) SWIG_fail;
26815 }
26816 {
26817 #if wxUSE_UNICODE
26818 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26819 #else
26820 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26821 #endif
26822 }
26823 return resultobj;
26824 fail:
26825 return NULL;
26826 }
26827
26828
26829 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26830 PyObject *resultobj = 0;
26831 wxPyApp *arg1 = (wxPyApp *) 0 ;
26832 wxString *arg2 = 0 ;
26833 void *argp1 = 0 ;
26834 int res1 = 0 ;
26835 bool temp2 = false ;
26836 PyObject * obj0 = 0 ;
26837 PyObject * obj1 = 0 ;
26838 char * kwnames[] = {
26839 (char *) "self",(char *) "name", NULL
26840 };
26841
26842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26844 if (!SWIG_IsOK(res1)) {
26845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26846 }
26847 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26848 {
26849 arg2 = wxString_in_helper(obj1);
26850 if (arg2 == NULL) SWIG_fail;
26851 temp2 = true;
26852 }
26853 {
26854 PyThreadState* __tstate = wxPyBeginAllowThreads();
26855 (arg1)->SetAppName((wxString const &)*arg2);
26856 wxPyEndAllowThreads(__tstate);
26857 if (PyErr_Occurred()) SWIG_fail;
26858 }
26859 resultobj = SWIG_Py_Void();
26860 {
26861 if (temp2)
26862 delete arg2;
26863 }
26864 return resultobj;
26865 fail:
26866 {
26867 if (temp2)
26868 delete arg2;
26869 }
26870 return NULL;
26871 }
26872
26873
26874 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26875 PyObject *resultobj = 0;
26876 wxPyApp *arg1 = (wxPyApp *) 0 ;
26877 wxString result;
26878 void *argp1 = 0 ;
26879 int res1 = 0 ;
26880 PyObject *swig_obj[1] ;
26881
26882 if (!args) SWIG_fail;
26883 swig_obj[0] = args;
26884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26885 if (!SWIG_IsOK(res1)) {
26886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26887 }
26888 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26889 {
26890 PyThreadState* __tstate = wxPyBeginAllowThreads();
26891 result = ((wxPyApp const *)arg1)->GetClassName();
26892 wxPyEndAllowThreads(__tstate);
26893 if (PyErr_Occurred()) SWIG_fail;
26894 }
26895 {
26896 #if wxUSE_UNICODE
26897 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26898 #else
26899 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26900 #endif
26901 }
26902 return resultobj;
26903 fail:
26904 return NULL;
26905 }
26906
26907
26908 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26909 PyObject *resultobj = 0;
26910 wxPyApp *arg1 = (wxPyApp *) 0 ;
26911 wxString *arg2 = 0 ;
26912 void *argp1 = 0 ;
26913 int res1 = 0 ;
26914 bool temp2 = false ;
26915 PyObject * obj0 = 0 ;
26916 PyObject * obj1 = 0 ;
26917 char * kwnames[] = {
26918 (char *) "self",(char *) "name", NULL
26919 };
26920
26921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
26922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26923 if (!SWIG_IsOK(res1)) {
26924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26925 }
26926 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26927 {
26928 arg2 = wxString_in_helper(obj1);
26929 if (arg2 == NULL) SWIG_fail;
26930 temp2 = true;
26931 }
26932 {
26933 PyThreadState* __tstate = wxPyBeginAllowThreads();
26934 (arg1)->SetClassName((wxString const &)*arg2);
26935 wxPyEndAllowThreads(__tstate);
26936 if (PyErr_Occurred()) SWIG_fail;
26937 }
26938 resultobj = SWIG_Py_Void();
26939 {
26940 if (temp2)
26941 delete arg2;
26942 }
26943 return resultobj;
26944 fail:
26945 {
26946 if (temp2)
26947 delete arg2;
26948 }
26949 return NULL;
26950 }
26951
26952
26953 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26954 PyObject *resultobj = 0;
26955 wxPyApp *arg1 = (wxPyApp *) 0 ;
26956 wxString *result = 0 ;
26957 void *argp1 = 0 ;
26958 int res1 = 0 ;
26959 PyObject *swig_obj[1] ;
26960
26961 if (!args) SWIG_fail;
26962 swig_obj[0] = args;
26963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26964 if (!SWIG_IsOK(res1)) {
26965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26966 }
26967 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26968 {
26969 PyThreadState* __tstate = wxPyBeginAllowThreads();
26970 {
26971 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
26972 result = (wxString *) &_result_ref;
26973 }
26974 wxPyEndAllowThreads(__tstate);
26975 if (PyErr_Occurred()) SWIG_fail;
26976 }
26977 {
26978 #if wxUSE_UNICODE
26979 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
26980 #else
26981 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
26982 #endif
26983 }
26984 return resultobj;
26985 fail:
26986 return NULL;
26987 }
26988
26989
26990 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26991 PyObject *resultobj = 0;
26992 wxPyApp *arg1 = (wxPyApp *) 0 ;
26993 wxString *arg2 = 0 ;
26994 void *argp1 = 0 ;
26995 int res1 = 0 ;
26996 bool temp2 = false ;
26997 PyObject * obj0 = 0 ;
26998 PyObject * obj1 = 0 ;
26999 char * kwnames[] = {
27000 (char *) "self",(char *) "name", NULL
27001 };
27002
27003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27005 if (!SWIG_IsOK(res1)) {
27006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27007 }
27008 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27009 {
27010 arg2 = wxString_in_helper(obj1);
27011 if (arg2 == NULL) SWIG_fail;
27012 temp2 = true;
27013 }
27014 {
27015 PyThreadState* __tstate = wxPyBeginAllowThreads();
27016 (arg1)->SetVendorName((wxString const &)*arg2);
27017 wxPyEndAllowThreads(__tstate);
27018 if (PyErr_Occurred()) SWIG_fail;
27019 }
27020 resultobj = SWIG_Py_Void();
27021 {
27022 if (temp2)
27023 delete arg2;
27024 }
27025 return resultobj;
27026 fail:
27027 {
27028 if (temp2)
27029 delete arg2;
27030 }
27031 return NULL;
27032 }
27033
27034
27035 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27036 PyObject *resultobj = 0;
27037 wxPyApp *arg1 = (wxPyApp *) 0 ;
27038 wxAppTraits *result = 0 ;
27039 void *argp1 = 0 ;
27040 int res1 = 0 ;
27041 PyObject *swig_obj[1] ;
27042
27043 if (!args) SWIG_fail;
27044 swig_obj[0] = args;
27045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27046 if (!SWIG_IsOK(res1)) {
27047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27048 }
27049 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27050 {
27051 PyThreadState* __tstate = wxPyBeginAllowThreads();
27052 result = (wxAppTraits *)(arg1)->GetTraits();
27053 wxPyEndAllowThreads(__tstate);
27054 if (PyErr_Occurred()) SWIG_fail;
27055 }
27056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27057 return resultobj;
27058 fail:
27059 return NULL;
27060 }
27061
27062
27063 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27064 PyObject *resultobj = 0;
27065 wxPyApp *arg1 = (wxPyApp *) 0 ;
27066 void *argp1 = 0 ;
27067 int res1 = 0 ;
27068 PyObject *swig_obj[1] ;
27069
27070 if (!args) SWIG_fail;
27071 swig_obj[0] = args;
27072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27073 if (!SWIG_IsOK(res1)) {
27074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27075 }
27076 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27077 {
27078 PyThreadState* __tstate = wxPyBeginAllowThreads();
27079 (arg1)->ProcessPendingEvents();
27080 wxPyEndAllowThreads(__tstate);
27081 if (PyErr_Occurred()) SWIG_fail;
27082 }
27083 resultobj = SWIG_Py_Void();
27084 return resultobj;
27085 fail:
27086 return NULL;
27087 }
27088
27089
27090 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27091 PyObject *resultobj = 0;
27092 wxPyApp *arg1 = (wxPyApp *) 0 ;
27093 bool arg2 = (bool) false ;
27094 bool result;
27095 void *argp1 = 0 ;
27096 int res1 = 0 ;
27097 bool val2 ;
27098 int ecode2 = 0 ;
27099 PyObject * obj0 = 0 ;
27100 PyObject * obj1 = 0 ;
27101 char * kwnames[] = {
27102 (char *) "self",(char *) "onlyIfNeeded", NULL
27103 };
27104
27105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27107 if (!SWIG_IsOK(res1)) {
27108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27109 }
27110 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27111 if (obj1) {
27112 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27113 if (!SWIG_IsOK(ecode2)) {
27114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27115 }
27116 arg2 = static_cast< bool >(val2);
27117 }
27118 {
27119 PyThreadState* __tstate = wxPyBeginAllowThreads();
27120 result = (bool)(arg1)->Yield(arg2);
27121 wxPyEndAllowThreads(__tstate);
27122 if (PyErr_Occurred()) SWIG_fail;
27123 }
27124 {
27125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27126 }
27127 return resultobj;
27128 fail:
27129 return NULL;
27130 }
27131
27132
27133 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27134 PyObject *resultobj = 0;
27135 wxPyApp *arg1 = (wxPyApp *) 0 ;
27136 void *argp1 = 0 ;
27137 int res1 = 0 ;
27138 PyObject *swig_obj[1] ;
27139
27140 if (!args) SWIG_fail;
27141 swig_obj[0] = args;
27142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27143 if (!SWIG_IsOK(res1)) {
27144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27145 }
27146 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27147 {
27148 PyThreadState* __tstate = wxPyBeginAllowThreads();
27149 (arg1)->WakeUpIdle();
27150 wxPyEndAllowThreads(__tstate);
27151 if (PyErr_Occurred()) SWIG_fail;
27152 }
27153 resultobj = SWIG_Py_Void();
27154 return resultobj;
27155 fail:
27156 return NULL;
27157 }
27158
27159
27160 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27161 PyObject *resultobj = 0;
27162 bool result;
27163
27164 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27165 {
27166 PyThreadState* __tstate = wxPyBeginAllowThreads();
27167 result = (bool)wxPyApp::IsMainLoopRunning();
27168 wxPyEndAllowThreads(__tstate);
27169 if (PyErr_Occurred()) SWIG_fail;
27170 }
27171 {
27172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27173 }
27174 return resultobj;
27175 fail:
27176 return NULL;
27177 }
27178
27179
27180 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27181 PyObject *resultobj = 0;
27182 wxPyApp *arg1 = (wxPyApp *) 0 ;
27183 int result;
27184 void *argp1 = 0 ;
27185 int res1 = 0 ;
27186 PyObject *swig_obj[1] ;
27187
27188 if (!args) SWIG_fail;
27189 swig_obj[0] = args;
27190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27191 if (!SWIG_IsOK(res1)) {
27192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27193 }
27194 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27195 {
27196 PyThreadState* __tstate = wxPyBeginAllowThreads();
27197 result = (int)(arg1)->MainLoop();
27198 wxPyEndAllowThreads(__tstate);
27199 if (PyErr_Occurred()) SWIG_fail;
27200 }
27201 resultobj = SWIG_From_int(static_cast< int >(result));
27202 return resultobj;
27203 fail:
27204 return NULL;
27205 }
27206
27207
27208 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27209 PyObject *resultobj = 0;
27210 wxPyApp *arg1 = (wxPyApp *) 0 ;
27211 void *argp1 = 0 ;
27212 int res1 = 0 ;
27213 PyObject *swig_obj[1] ;
27214
27215 if (!args) SWIG_fail;
27216 swig_obj[0] = args;
27217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27218 if (!SWIG_IsOK(res1)) {
27219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27220 }
27221 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27222 {
27223 PyThreadState* __tstate = wxPyBeginAllowThreads();
27224 (arg1)->Exit();
27225 wxPyEndAllowThreads(__tstate);
27226 if (PyErr_Occurred()) SWIG_fail;
27227 }
27228 resultobj = SWIG_Py_Void();
27229 return resultobj;
27230 fail:
27231 return NULL;
27232 }
27233
27234
27235 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27236 PyObject *resultobj = 0;
27237 wxPyApp *arg1 = (wxPyApp *) 0 ;
27238 void *argp1 = 0 ;
27239 int res1 = 0 ;
27240 PyObject *swig_obj[1] ;
27241
27242 if (!args) SWIG_fail;
27243 swig_obj[0] = args;
27244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27245 if (!SWIG_IsOK(res1)) {
27246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27247 }
27248 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27249 {
27250 PyThreadState* __tstate = wxPyBeginAllowThreads();
27251 (arg1)->ExitMainLoop();
27252 wxPyEndAllowThreads(__tstate);
27253 if (PyErr_Occurred()) SWIG_fail;
27254 }
27255 resultobj = SWIG_Py_Void();
27256 return resultobj;
27257 fail:
27258 return NULL;
27259 }
27260
27261
27262 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27263 PyObject *resultobj = 0;
27264 wxPyApp *arg1 = (wxPyApp *) 0 ;
27265 bool result;
27266 void *argp1 = 0 ;
27267 int res1 = 0 ;
27268 PyObject *swig_obj[1] ;
27269
27270 if (!args) SWIG_fail;
27271 swig_obj[0] = args;
27272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27273 if (!SWIG_IsOK(res1)) {
27274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27275 }
27276 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27277 {
27278 PyThreadState* __tstate = wxPyBeginAllowThreads();
27279 result = (bool)(arg1)->Pending();
27280 wxPyEndAllowThreads(__tstate);
27281 if (PyErr_Occurred()) SWIG_fail;
27282 }
27283 {
27284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27285 }
27286 return resultobj;
27287 fail:
27288 return NULL;
27289 }
27290
27291
27292 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27293 PyObject *resultobj = 0;
27294 wxPyApp *arg1 = (wxPyApp *) 0 ;
27295 bool result;
27296 void *argp1 = 0 ;
27297 int res1 = 0 ;
27298 PyObject *swig_obj[1] ;
27299
27300 if (!args) SWIG_fail;
27301 swig_obj[0] = args;
27302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27303 if (!SWIG_IsOK(res1)) {
27304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27305 }
27306 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27307 {
27308 PyThreadState* __tstate = wxPyBeginAllowThreads();
27309 result = (bool)(arg1)->Dispatch();
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_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27323 PyObject *resultobj = 0;
27324 wxPyApp *arg1 = (wxPyApp *) 0 ;
27325 bool result;
27326 void *argp1 = 0 ;
27327 int res1 = 0 ;
27328 PyObject *swig_obj[1] ;
27329
27330 if (!args) SWIG_fail;
27331 swig_obj[0] = args;
27332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27333 if (!SWIG_IsOK(res1)) {
27334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27335 }
27336 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27337 {
27338 PyThreadState* __tstate = wxPyBeginAllowThreads();
27339 result = (bool)(arg1)->ProcessIdle();
27340 wxPyEndAllowThreads(__tstate);
27341 if (PyErr_Occurred()) SWIG_fail;
27342 }
27343 {
27344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27345 }
27346 return resultobj;
27347 fail:
27348 return NULL;
27349 }
27350
27351
27352 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27353 PyObject *resultobj = 0;
27354 wxPyApp *arg1 = (wxPyApp *) 0 ;
27355 wxWindow *arg2 = (wxWindow *) 0 ;
27356 wxIdleEvent *arg3 = 0 ;
27357 bool result;
27358 void *argp1 = 0 ;
27359 int res1 = 0 ;
27360 void *argp2 = 0 ;
27361 int res2 = 0 ;
27362 void *argp3 = 0 ;
27363 int res3 = 0 ;
27364 PyObject * obj0 = 0 ;
27365 PyObject * obj1 = 0 ;
27366 PyObject * obj2 = 0 ;
27367 char * kwnames[] = {
27368 (char *) "self",(char *) "win",(char *) "event", NULL
27369 };
27370
27371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27373 if (!SWIG_IsOK(res1)) {
27374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27375 }
27376 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27377 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27378 if (!SWIG_IsOK(res2)) {
27379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27380 }
27381 arg2 = reinterpret_cast< wxWindow * >(argp2);
27382 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27383 if (!SWIG_IsOK(res3)) {
27384 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27385 }
27386 if (!argp3) {
27387 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27388 }
27389 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27390 {
27391 PyThreadState* __tstate = wxPyBeginAllowThreads();
27392 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27393 wxPyEndAllowThreads(__tstate);
27394 if (PyErr_Occurred()) SWIG_fail;
27395 }
27396 {
27397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27398 }
27399 return resultobj;
27400 fail:
27401 return NULL;
27402 }
27403
27404
27405 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27406 PyObject *resultobj = 0;
27407 wxPyApp *arg1 = (wxPyApp *) 0 ;
27408 bool result;
27409 void *argp1 = 0 ;
27410 int res1 = 0 ;
27411 PyObject *swig_obj[1] ;
27412
27413 if (!args) SWIG_fail;
27414 swig_obj[0] = args;
27415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27416 if (!SWIG_IsOK(res1)) {
27417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27418 }
27419 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27420 {
27421 PyThreadState* __tstate = wxPyBeginAllowThreads();
27422 result = (bool)((wxPyApp const *)arg1)->IsActive();
27423 wxPyEndAllowThreads(__tstate);
27424 if (PyErr_Occurred()) SWIG_fail;
27425 }
27426 {
27427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27428 }
27429 return resultobj;
27430 fail:
27431 return NULL;
27432 }
27433
27434
27435 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27436 PyObject *resultobj = 0;
27437 wxPyApp *arg1 = (wxPyApp *) 0 ;
27438 wxWindow *arg2 = (wxWindow *) 0 ;
27439 void *argp1 = 0 ;
27440 int res1 = 0 ;
27441 void *argp2 = 0 ;
27442 int res2 = 0 ;
27443 PyObject * obj0 = 0 ;
27444 PyObject * obj1 = 0 ;
27445 char * kwnames[] = {
27446 (char *) "self",(char *) "win", NULL
27447 };
27448
27449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27451 if (!SWIG_IsOK(res1)) {
27452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27453 }
27454 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27455 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27456 if (!SWIG_IsOK(res2)) {
27457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27458 }
27459 arg2 = reinterpret_cast< wxWindow * >(argp2);
27460 {
27461 PyThreadState* __tstate = wxPyBeginAllowThreads();
27462 (arg1)->SetTopWindow(arg2);
27463 wxPyEndAllowThreads(__tstate);
27464 if (PyErr_Occurred()) SWIG_fail;
27465 }
27466 resultobj = SWIG_Py_Void();
27467 return resultobj;
27468 fail:
27469 return NULL;
27470 }
27471
27472
27473 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27474 PyObject *resultobj = 0;
27475 wxPyApp *arg1 = (wxPyApp *) 0 ;
27476 wxWindow *result = 0 ;
27477 void *argp1 = 0 ;
27478 int res1 = 0 ;
27479 PyObject *swig_obj[1] ;
27480
27481 if (!args) SWIG_fail;
27482 swig_obj[0] = args;
27483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27484 if (!SWIG_IsOK(res1)) {
27485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27486 }
27487 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27488 {
27489 PyThreadState* __tstate = wxPyBeginAllowThreads();
27490 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27491 wxPyEndAllowThreads(__tstate);
27492 if (PyErr_Occurred()) SWIG_fail;
27493 }
27494 {
27495 resultobj = wxPyMake_wxObject(result, (bool)0);
27496 }
27497 return resultobj;
27498 fail:
27499 return NULL;
27500 }
27501
27502
27503 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27504 PyObject *resultobj = 0;
27505 wxPyApp *arg1 = (wxPyApp *) 0 ;
27506 bool arg2 ;
27507 void *argp1 = 0 ;
27508 int res1 = 0 ;
27509 bool val2 ;
27510 int ecode2 = 0 ;
27511 PyObject * obj0 = 0 ;
27512 PyObject * obj1 = 0 ;
27513 char * kwnames[] = {
27514 (char *) "self",(char *) "flag", NULL
27515 };
27516
27517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27519 if (!SWIG_IsOK(res1)) {
27520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27521 }
27522 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27523 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27524 if (!SWIG_IsOK(ecode2)) {
27525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27526 }
27527 arg2 = static_cast< bool >(val2);
27528 {
27529 PyThreadState* __tstate = wxPyBeginAllowThreads();
27530 (arg1)->SetExitOnFrameDelete(arg2);
27531 wxPyEndAllowThreads(__tstate);
27532 if (PyErr_Occurred()) SWIG_fail;
27533 }
27534 resultobj = SWIG_Py_Void();
27535 return resultobj;
27536 fail:
27537 return NULL;
27538 }
27539
27540
27541 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27542 PyObject *resultobj = 0;
27543 wxPyApp *arg1 = (wxPyApp *) 0 ;
27544 bool result;
27545 void *argp1 = 0 ;
27546 int res1 = 0 ;
27547 PyObject *swig_obj[1] ;
27548
27549 if (!args) SWIG_fail;
27550 swig_obj[0] = args;
27551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27552 if (!SWIG_IsOK(res1)) {
27553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27554 }
27555 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27556 {
27557 PyThreadState* __tstate = wxPyBeginAllowThreads();
27558 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27559 wxPyEndAllowThreads(__tstate);
27560 if (PyErr_Occurred()) SWIG_fail;
27561 }
27562 {
27563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27564 }
27565 return resultobj;
27566 fail:
27567 return NULL;
27568 }
27569
27570
27571 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27572 PyObject *resultobj = 0;
27573 wxPyApp *arg1 = (wxPyApp *) 0 ;
27574 bool arg2 ;
27575 void *argp1 = 0 ;
27576 int res1 = 0 ;
27577 bool val2 ;
27578 int ecode2 = 0 ;
27579 PyObject * obj0 = 0 ;
27580 PyObject * obj1 = 0 ;
27581 char * kwnames[] = {
27582 (char *) "self",(char *) "flag", NULL
27583 };
27584
27585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27587 if (!SWIG_IsOK(res1)) {
27588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27589 }
27590 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27591 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27592 if (!SWIG_IsOK(ecode2)) {
27593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27594 }
27595 arg2 = static_cast< bool >(val2);
27596 {
27597 PyThreadState* __tstate = wxPyBeginAllowThreads();
27598 (arg1)->SetUseBestVisual(arg2);
27599 wxPyEndAllowThreads(__tstate);
27600 if (PyErr_Occurred()) SWIG_fail;
27601 }
27602 resultobj = SWIG_Py_Void();
27603 return resultobj;
27604 fail:
27605 return NULL;
27606 }
27607
27608
27609 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27610 PyObject *resultobj = 0;
27611 wxPyApp *arg1 = (wxPyApp *) 0 ;
27612 bool result;
27613 void *argp1 = 0 ;
27614 int res1 = 0 ;
27615 PyObject *swig_obj[1] ;
27616
27617 if (!args) SWIG_fail;
27618 swig_obj[0] = args;
27619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27620 if (!SWIG_IsOK(res1)) {
27621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27622 }
27623 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27624 {
27625 PyThreadState* __tstate = wxPyBeginAllowThreads();
27626 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27627 wxPyEndAllowThreads(__tstate);
27628 if (PyErr_Occurred()) SWIG_fail;
27629 }
27630 {
27631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27632 }
27633 return resultobj;
27634 fail:
27635 return NULL;
27636 }
27637
27638
27639 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27640 PyObject *resultobj = 0;
27641 wxPyApp *arg1 = (wxPyApp *) 0 ;
27642 int arg2 ;
27643 void *argp1 = 0 ;
27644 int res1 = 0 ;
27645 int val2 ;
27646 int ecode2 = 0 ;
27647 PyObject * obj0 = 0 ;
27648 PyObject * obj1 = 0 ;
27649 char * kwnames[] = {
27650 (char *) "self",(char *) "mode", NULL
27651 };
27652
27653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27655 if (!SWIG_IsOK(res1)) {
27656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27657 }
27658 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27659 ecode2 = SWIG_AsVal_int(obj1, &val2);
27660 if (!SWIG_IsOK(ecode2)) {
27661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27662 }
27663 arg2 = static_cast< int >(val2);
27664 {
27665 PyThreadState* __tstate = wxPyBeginAllowThreads();
27666 (arg1)->SetPrintMode(arg2);
27667 wxPyEndAllowThreads(__tstate);
27668 if (PyErr_Occurred()) SWIG_fail;
27669 }
27670 resultobj = SWIG_Py_Void();
27671 return resultobj;
27672 fail:
27673 return NULL;
27674 }
27675
27676
27677 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27678 PyObject *resultobj = 0;
27679 wxPyApp *arg1 = (wxPyApp *) 0 ;
27680 int result;
27681 void *argp1 = 0 ;
27682 int res1 = 0 ;
27683 PyObject *swig_obj[1] ;
27684
27685 if (!args) SWIG_fail;
27686 swig_obj[0] = args;
27687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27688 if (!SWIG_IsOK(res1)) {
27689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27690 }
27691 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27692 {
27693 PyThreadState* __tstate = wxPyBeginAllowThreads();
27694 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27695 wxPyEndAllowThreads(__tstate);
27696 if (PyErr_Occurred()) SWIG_fail;
27697 }
27698 resultobj = SWIG_From_int(static_cast< int >(result));
27699 return resultobj;
27700 fail:
27701 return NULL;
27702 }
27703
27704
27705 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27706 PyObject *resultobj = 0;
27707 wxPyApp *arg1 = (wxPyApp *) 0 ;
27708 int arg2 ;
27709 void *argp1 = 0 ;
27710 int res1 = 0 ;
27711 int val2 ;
27712 int ecode2 = 0 ;
27713 PyObject * obj0 = 0 ;
27714 PyObject * obj1 = 0 ;
27715 char * kwnames[] = {
27716 (char *) "self",(char *) "mode", NULL
27717 };
27718
27719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27721 if (!SWIG_IsOK(res1)) {
27722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27723 }
27724 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27725 ecode2 = SWIG_AsVal_int(obj1, &val2);
27726 if (!SWIG_IsOK(ecode2)) {
27727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27728 }
27729 arg2 = static_cast< int >(val2);
27730 {
27731 PyThreadState* __tstate = wxPyBeginAllowThreads();
27732 (arg1)->SetAssertMode(arg2);
27733 wxPyEndAllowThreads(__tstate);
27734 if (PyErr_Occurred()) SWIG_fail;
27735 }
27736 resultobj = SWIG_Py_Void();
27737 return resultobj;
27738 fail:
27739 return NULL;
27740 }
27741
27742
27743 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27744 PyObject *resultobj = 0;
27745 wxPyApp *arg1 = (wxPyApp *) 0 ;
27746 int result;
27747 void *argp1 = 0 ;
27748 int res1 = 0 ;
27749 PyObject *swig_obj[1] ;
27750
27751 if (!args) SWIG_fail;
27752 swig_obj[0] = args;
27753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27754 if (!SWIG_IsOK(res1)) {
27755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27756 }
27757 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27758 {
27759 PyThreadState* __tstate = wxPyBeginAllowThreads();
27760 result = (int)(arg1)->GetAssertMode();
27761 wxPyEndAllowThreads(__tstate);
27762 if (PyErr_Occurred()) SWIG_fail;
27763 }
27764 resultobj = SWIG_From_int(static_cast< int >(result));
27765 return resultobj;
27766 fail:
27767 return NULL;
27768 }
27769
27770
27771 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27772 PyObject *resultobj = 0;
27773 bool result;
27774
27775 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27776 {
27777 PyThreadState* __tstate = wxPyBeginAllowThreads();
27778 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27779 wxPyEndAllowThreads(__tstate);
27780 if (PyErr_Occurred()) SWIG_fail;
27781 }
27782 {
27783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27784 }
27785 return resultobj;
27786 fail:
27787 return NULL;
27788 }
27789
27790
27791 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27792 PyObject *resultobj = 0;
27793 long result;
27794
27795 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27796 {
27797 PyThreadState* __tstate = wxPyBeginAllowThreads();
27798 result = (long)wxPyApp::GetMacAboutMenuItemId();
27799 wxPyEndAllowThreads(__tstate);
27800 if (PyErr_Occurred()) SWIG_fail;
27801 }
27802 resultobj = SWIG_From_long(static_cast< long >(result));
27803 return resultobj;
27804 fail:
27805 return NULL;
27806 }
27807
27808
27809 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27810 PyObject *resultobj = 0;
27811 long result;
27812
27813 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27814 {
27815 PyThreadState* __tstate = wxPyBeginAllowThreads();
27816 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27817 wxPyEndAllowThreads(__tstate);
27818 if (PyErr_Occurred()) SWIG_fail;
27819 }
27820 resultobj = SWIG_From_long(static_cast< long >(result));
27821 return resultobj;
27822 fail:
27823 return NULL;
27824 }
27825
27826
27827 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27828 PyObject *resultobj = 0;
27829 long result;
27830
27831 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27832 {
27833 PyThreadState* __tstate = wxPyBeginAllowThreads();
27834 result = (long)wxPyApp::GetMacExitMenuItemId();
27835 wxPyEndAllowThreads(__tstate);
27836 if (PyErr_Occurred()) SWIG_fail;
27837 }
27838 resultobj = SWIG_From_long(static_cast< long >(result));
27839 return resultobj;
27840 fail:
27841 return NULL;
27842 }
27843
27844
27845 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27846 PyObject *resultobj = 0;
27847 wxString result;
27848
27849 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27850 {
27851 PyThreadState* __tstate = wxPyBeginAllowThreads();
27852 result = wxPyApp::GetMacHelpMenuTitleName();
27853 wxPyEndAllowThreads(__tstate);
27854 if (PyErr_Occurred()) SWIG_fail;
27855 }
27856 {
27857 #if wxUSE_UNICODE
27858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27859 #else
27860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27861 #endif
27862 }
27863 return resultobj;
27864 fail:
27865 return NULL;
27866 }
27867
27868
27869 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27870 PyObject *resultobj = 0;
27871 bool arg1 ;
27872 bool val1 ;
27873 int ecode1 = 0 ;
27874 PyObject * obj0 = 0 ;
27875 char * kwnames[] = {
27876 (char *) "val", NULL
27877 };
27878
27879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
27880 ecode1 = SWIG_AsVal_bool(obj0, &val1);
27881 if (!SWIG_IsOK(ecode1)) {
27882 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
27883 }
27884 arg1 = static_cast< bool >(val1);
27885 {
27886 PyThreadState* __tstate = wxPyBeginAllowThreads();
27887 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
27888 wxPyEndAllowThreads(__tstate);
27889 if (PyErr_Occurred()) SWIG_fail;
27890 }
27891 resultobj = SWIG_Py_Void();
27892 return resultobj;
27893 fail:
27894 return NULL;
27895 }
27896
27897
27898 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27899 PyObject *resultobj = 0;
27900 long arg1 ;
27901 long val1 ;
27902 int ecode1 = 0 ;
27903 PyObject * obj0 = 0 ;
27904 char * kwnames[] = {
27905 (char *) "val", NULL
27906 };
27907
27908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
27909 ecode1 = SWIG_AsVal_long(obj0, &val1);
27910 if (!SWIG_IsOK(ecode1)) {
27911 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
27912 }
27913 arg1 = static_cast< long >(val1);
27914 {
27915 PyThreadState* __tstate = wxPyBeginAllowThreads();
27916 wxPyApp::SetMacAboutMenuItemId(arg1);
27917 wxPyEndAllowThreads(__tstate);
27918 if (PyErr_Occurred()) SWIG_fail;
27919 }
27920 resultobj = SWIG_Py_Void();
27921 return resultobj;
27922 fail:
27923 return NULL;
27924 }
27925
27926
27927 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27928 PyObject *resultobj = 0;
27929 long arg1 ;
27930 long val1 ;
27931 int ecode1 = 0 ;
27932 PyObject * obj0 = 0 ;
27933 char * kwnames[] = {
27934 (char *) "val", NULL
27935 };
27936
27937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
27938 ecode1 = SWIG_AsVal_long(obj0, &val1);
27939 if (!SWIG_IsOK(ecode1)) {
27940 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
27941 }
27942 arg1 = static_cast< long >(val1);
27943 {
27944 PyThreadState* __tstate = wxPyBeginAllowThreads();
27945 wxPyApp::SetMacPreferencesMenuItemId(arg1);
27946 wxPyEndAllowThreads(__tstate);
27947 if (PyErr_Occurred()) SWIG_fail;
27948 }
27949 resultobj = SWIG_Py_Void();
27950 return resultobj;
27951 fail:
27952 return NULL;
27953 }
27954
27955
27956 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27957 PyObject *resultobj = 0;
27958 long arg1 ;
27959 long val1 ;
27960 int ecode1 = 0 ;
27961 PyObject * obj0 = 0 ;
27962 char * kwnames[] = {
27963 (char *) "val", NULL
27964 };
27965
27966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
27967 ecode1 = SWIG_AsVal_long(obj0, &val1);
27968 if (!SWIG_IsOK(ecode1)) {
27969 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
27970 }
27971 arg1 = static_cast< long >(val1);
27972 {
27973 PyThreadState* __tstate = wxPyBeginAllowThreads();
27974 wxPyApp::SetMacExitMenuItemId(arg1);
27975 wxPyEndAllowThreads(__tstate);
27976 if (PyErr_Occurred()) SWIG_fail;
27977 }
27978 resultobj = SWIG_Py_Void();
27979 return resultobj;
27980 fail:
27981 return NULL;
27982 }
27983
27984
27985 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27986 PyObject *resultobj = 0;
27987 wxString *arg1 = 0 ;
27988 bool temp1 = false ;
27989 PyObject * obj0 = 0 ;
27990 char * kwnames[] = {
27991 (char *) "val", NULL
27992 };
27993
27994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
27995 {
27996 arg1 = wxString_in_helper(obj0);
27997 if (arg1 == NULL) SWIG_fail;
27998 temp1 = true;
27999 }
28000 {
28001 PyThreadState* __tstate = wxPyBeginAllowThreads();
28002 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28003 wxPyEndAllowThreads(__tstate);
28004 if (PyErr_Occurred()) SWIG_fail;
28005 }
28006 resultobj = SWIG_Py_Void();
28007 {
28008 if (temp1)
28009 delete arg1;
28010 }
28011 return resultobj;
28012 fail:
28013 {
28014 if (temp1)
28015 delete arg1;
28016 }
28017 return NULL;
28018 }
28019
28020
28021 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28022 PyObject *resultobj = 0;
28023 wxPyApp *arg1 = (wxPyApp *) 0 ;
28024 void *argp1 = 0 ;
28025 int res1 = 0 ;
28026 PyObject *swig_obj[1] ;
28027
28028 if (!args) SWIG_fail;
28029 swig_obj[0] = args;
28030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28031 if (!SWIG_IsOK(res1)) {
28032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28033 }
28034 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28035 {
28036 PyThreadState* __tstate = wxPyBeginAllowThreads();
28037 (arg1)->_BootstrapApp();
28038 wxPyEndAllowThreads(__tstate);
28039 if (PyErr_Occurred()) SWIG_fail;
28040 }
28041 resultobj = SWIG_Py_Void();
28042 return resultobj;
28043 fail:
28044 return NULL;
28045 }
28046
28047
28048 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28049 PyObject *resultobj = 0;
28050 int result;
28051
28052 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28053 {
28054 PyThreadState* __tstate = wxPyBeginAllowThreads();
28055 result = (int)wxPyApp_GetComCtl32Version();
28056 wxPyEndAllowThreads(__tstate);
28057 if (PyErr_Occurred()) SWIG_fail;
28058 }
28059 resultobj = SWIG_From_int(static_cast< int >(result));
28060 return resultobj;
28061 fail:
28062 return NULL;
28063 }
28064
28065
28066 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28067 PyObject *obj;
28068 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28069 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28070 return SWIG_Py_Void();
28071 }
28072
28073 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28074 return SWIG_Python_InitShadowInstance(args);
28075 }
28076
28077 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28078 PyObject *resultobj = 0;
28079
28080 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28081 {
28082 PyThreadState* __tstate = wxPyBeginAllowThreads();
28083 wxExit();
28084 wxPyEndAllowThreads(__tstate);
28085 if (PyErr_Occurred()) SWIG_fail;
28086 }
28087 resultobj = SWIG_Py_Void();
28088 return resultobj;
28089 fail:
28090 return NULL;
28091 }
28092
28093
28094 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28095 PyObject *resultobj = 0;
28096 bool result;
28097
28098 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28099 {
28100 PyThreadState* __tstate = wxPyBeginAllowThreads();
28101 result = (bool)wxYield();
28102 wxPyEndAllowThreads(__tstate);
28103 if (PyErr_Occurred()) SWIG_fail;
28104 }
28105 {
28106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28107 }
28108 return resultobj;
28109 fail:
28110 return NULL;
28111 }
28112
28113
28114 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28115 PyObject *resultobj = 0;
28116 bool result;
28117
28118 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28119 {
28120 PyThreadState* __tstate = wxPyBeginAllowThreads();
28121 result = (bool)wxYieldIfNeeded();
28122 wxPyEndAllowThreads(__tstate);
28123 if (PyErr_Occurred()) SWIG_fail;
28124 }
28125 {
28126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28127 }
28128 return resultobj;
28129 fail:
28130 return NULL;
28131 }
28132
28133
28134 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28135 PyObject *resultobj = 0;
28136 wxWindow *arg1 = (wxWindow *) NULL ;
28137 bool arg2 = (bool) false ;
28138 bool result;
28139 void *argp1 = 0 ;
28140 int res1 = 0 ;
28141 bool val2 ;
28142 int ecode2 = 0 ;
28143 PyObject * obj0 = 0 ;
28144 PyObject * obj1 = 0 ;
28145 char * kwnames[] = {
28146 (char *) "win",(char *) "onlyIfNeeded", NULL
28147 };
28148
28149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28150 if (obj0) {
28151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28152 if (!SWIG_IsOK(res1)) {
28153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28154 }
28155 arg1 = reinterpret_cast< wxWindow * >(argp1);
28156 }
28157 if (obj1) {
28158 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28159 if (!SWIG_IsOK(ecode2)) {
28160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28161 }
28162 arg2 = static_cast< bool >(val2);
28163 }
28164 {
28165 PyThreadState* __tstate = wxPyBeginAllowThreads();
28166 result = (bool)wxSafeYield(arg1,arg2);
28167 wxPyEndAllowThreads(__tstate);
28168 if (PyErr_Occurred()) SWIG_fail;
28169 }
28170 {
28171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28172 }
28173 return resultobj;
28174 fail:
28175 return NULL;
28176 }
28177
28178
28179 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28180 PyObject *resultobj = 0;
28181
28182 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28183 {
28184 PyThreadState* __tstate = wxPyBeginAllowThreads();
28185 wxWakeUpIdle();
28186 wxPyEndAllowThreads(__tstate);
28187 if (PyErr_Occurred()) SWIG_fail;
28188 }
28189 resultobj = SWIG_Py_Void();
28190 return resultobj;
28191 fail:
28192 return NULL;
28193 }
28194
28195
28196 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28197 PyObject *resultobj = 0;
28198 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28199 wxEvent *arg2 = 0 ;
28200 void *argp1 = 0 ;
28201 int res1 = 0 ;
28202 void *argp2 = 0 ;
28203 int res2 = 0 ;
28204 PyObject * obj0 = 0 ;
28205 PyObject * obj1 = 0 ;
28206 char * kwnames[] = {
28207 (char *) "dest",(char *) "event", NULL
28208 };
28209
28210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28212 if (!SWIG_IsOK(res1)) {
28213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28214 }
28215 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28216 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28217 if (!SWIG_IsOK(res2)) {
28218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28219 }
28220 if (!argp2) {
28221 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28222 }
28223 arg2 = reinterpret_cast< wxEvent * >(argp2);
28224 {
28225 PyThreadState* __tstate = wxPyBeginAllowThreads();
28226 wxPostEvent(arg1,*arg2);
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_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28238 PyObject *resultobj = 0;
28239
28240 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28241 {
28242 PyThreadState* __tstate = wxPyBeginAllowThreads();
28243 wxApp_CleanUp();
28244 wxPyEndAllowThreads(__tstate);
28245 if (PyErr_Occurred()) SWIG_fail;
28246 }
28247 resultobj = SWIG_Py_Void();
28248 return resultobj;
28249 fail:
28250 return NULL;
28251 }
28252
28253
28254 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28255 PyObject *resultobj = 0;
28256 wxPyApp *result = 0 ;
28257
28258 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28259 {
28260 PyThreadState* __tstate = wxPyBeginAllowThreads();
28261 result = (wxPyApp *)wxPyGetApp();
28262 wxPyEndAllowThreads(__tstate);
28263 if (PyErr_Occurred()) SWIG_fail;
28264 }
28265 {
28266 resultobj = wxPyMake_wxObject(result, 0);
28267 }
28268 return resultobj;
28269 fail:
28270 return NULL;
28271 }
28272
28273
28274 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28275 PyObject *resultobj = 0;
28276 char *arg1 = (char *) 0 ;
28277 int res1 ;
28278 char *buf1 = 0 ;
28279 int alloc1 = 0 ;
28280 PyObject * obj0 = 0 ;
28281 char * kwnames[] = {
28282 (char *) "encoding", NULL
28283 };
28284
28285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28286 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28287 if (!SWIG_IsOK(res1)) {
28288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28289 }
28290 arg1 = buf1;
28291 {
28292 PyThreadState* __tstate = wxPyBeginAllowThreads();
28293 wxSetDefaultPyEncoding((char const *)arg1);
28294 wxPyEndAllowThreads(__tstate);
28295 if (PyErr_Occurred()) SWIG_fail;
28296 }
28297 resultobj = SWIG_Py_Void();
28298 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28299 return resultobj;
28300 fail:
28301 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28302 return NULL;
28303 }
28304
28305
28306 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28307 PyObject *resultobj = 0;
28308 char *result = 0 ;
28309
28310 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28311 {
28312 PyThreadState* __tstate = wxPyBeginAllowThreads();
28313 result = (char *)wxGetDefaultPyEncoding();
28314 wxPyEndAllowThreads(__tstate);
28315 if (PyErr_Occurred()) SWIG_fail;
28316 }
28317 resultobj = SWIG_FromCharPtr(result);
28318 return resultobj;
28319 fail:
28320 return NULL;
28321 }
28322
28323
28324 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28325 PyObject *resultobj = 0;
28326 wxEventLoop *result = 0 ;
28327
28328 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28329 {
28330 PyThreadState* __tstate = wxPyBeginAllowThreads();
28331 result = (wxEventLoop *)new wxEventLoop();
28332 wxPyEndAllowThreads(__tstate);
28333 if (PyErr_Occurred()) SWIG_fail;
28334 }
28335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28336 return resultobj;
28337 fail:
28338 return NULL;
28339 }
28340
28341
28342 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28343 PyObject *resultobj = 0;
28344 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28345 void *argp1 = 0 ;
28346 int res1 = 0 ;
28347 PyObject *swig_obj[1] ;
28348
28349 if (!args) SWIG_fail;
28350 swig_obj[0] = args;
28351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28352 if (!SWIG_IsOK(res1)) {
28353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28354 }
28355 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28356 {
28357 PyThreadState* __tstate = wxPyBeginAllowThreads();
28358 delete arg1;
28359
28360 wxPyEndAllowThreads(__tstate);
28361 if (PyErr_Occurred()) SWIG_fail;
28362 }
28363 resultobj = SWIG_Py_Void();
28364 return resultobj;
28365 fail:
28366 return NULL;
28367 }
28368
28369
28370 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28371 PyObject *resultobj = 0;
28372 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28373 int result;
28374 void *argp1 = 0 ;
28375 int res1 = 0 ;
28376 PyObject *swig_obj[1] ;
28377
28378 if (!args) SWIG_fail;
28379 swig_obj[0] = args;
28380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28381 if (!SWIG_IsOK(res1)) {
28382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28383 }
28384 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28385 {
28386 PyThreadState* __tstate = wxPyBeginAllowThreads();
28387 result = (int)(arg1)->Run();
28388 wxPyEndAllowThreads(__tstate);
28389 if (PyErr_Occurred()) SWIG_fail;
28390 }
28391 resultobj = SWIG_From_int(static_cast< int >(result));
28392 return resultobj;
28393 fail:
28394 return NULL;
28395 }
28396
28397
28398 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28399 PyObject *resultobj = 0;
28400 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28401 int arg2 = (int) 0 ;
28402 void *argp1 = 0 ;
28403 int res1 = 0 ;
28404 int val2 ;
28405 int ecode2 = 0 ;
28406 PyObject * obj0 = 0 ;
28407 PyObject * obj1 = 0 ;
28408 char * kwnames[] = {
28409 (char *) "self",(char *) "rc", NULL
28410 };
28411
28412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28414 if (!SWIG_IsOK(res1)) {
28415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28416 }
28417 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28418 if (obj1) {
28419 ecode2 = SWIG_AsVal_int(obj1, &val2);
28420 if (!SWIG_IsOK(ecode2)) {
28421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28422 }
28423 arg2 = static_cast< int >(val2);
28424 }
28425 {
28426 PyThreadState* __tstate = wxPyBeginAllowThreads();
28427 (arg1)->Exit(arg2);
28428 wxPyEndAllowThreads(__tstate);
28429 if (PyErr_Occurred()) SWIG_fail;
28430 }
28431 resultobj = SWIG_Py_Void();
28432 return resultobj;
28433 fail:
28434 return NULL;
28435 }
28436
28437
28438 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28439 PyObject *resultobj = 0;
28440 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28441 bool result;
28442 void *argp1 = 0 ;
28443 int res1 = 0 ;
28444 PyObject *swig_obj[1] ;
28445
28446 if (!args) SWIG_fail;
28447 swig_obj[0] = args;
28448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28449 if (!SWIG_IsOK(res1)) {
28450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28451 }
28452 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28453 {
28454 PyThreadState* __tstate = wxPyBeginAllowThreads();
28455 result = (bool)((wxEventLoop const *)arg1)->Pending();
28456 wxPyEndAllowThreads(__tstate);
28457 if (PyErr_Occurred()) SWIG_fail;
28458 }
28459 {
28460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28461 }
28462 return resultobj;
28463 fail:
28464 return NULL;
28465 }
28466
28467
28468 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28469 PyObject *resultobj = 0;
28470 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28471 bool result;
28472 void *argp1 = 0 ;
28473 int res1 = 0 ;
28474 PyObject *swig_obj[1] ;
28475
28476 if (!args) SWIG_fail;
28477 swig_obj[0] = args;
28478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28479 if (!SWIG_IsOK(res1)) {
28480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28481 }
28482 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28483 {
28484 PyThreadState* __tstate = wxPyBeginAllowThreads();
28485 result = (bool)(arg1)->Dispatch();
28486 wxPyEndAllowThreads(__tstate);
28487 if (PyErr_Occurred()) SWIG_fail;
28488 }
28489 {
28490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28491 }
28492 return resultobj;
28493 fail:
28494 return NULL;
28495 }
28496
28497
28498 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28499 PyObject *resultobj = 0;
28500 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28501 bool result;
28502 void *argp1 = 0 ;
28503 int res1 = 0 ;
28504 PyObject *swig_obj[1] ;
28505
28506 if (!args) SWIG_fail;
28507 swig_obj[0] = args;
28508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28509 if (!SWIG_IsOK(res1)) {
28510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28511 }
28512 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28513 {
28514 PyThreadState* __tstate = wxPyBeginAllowThreads();
28515 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28516 wxPyEndAllowThreads(__tstate);
28517 if (PyErr_Occurred()) SWIG_fail;
28518 }
28519 {
28520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28521 }
28522 return resultobj;
28523 fail:
28524 return NULL;
28525 }
28526
28527
28528 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28529 PyObject *resultobj = 0;
28530 wxEventLoop *result = 0 ;
28531
28532 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28533 {
28534 PyThreadState* __tstate = wxPyBeginAllowThreads();
28535 result = (wxEventLoop *)wxEventLoop::GetActive();
28536 wxPyEndAllowThreads(__tstate);
28537 if (PyErr_Occurred()) SWIG_fail;
28538 }
28539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28540 return resultobj;
28541 fail:
28542 return NULL;
28543 }
28544
28545
28546 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28547 PyObject *resultobj = 0;
28548 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28549 void *argp1 = 0 ;
28550 int res1 = 0 ;
28551 PyObject * obj0 = 0 ;
28552 char * kwnames[] = {
28553 (char *) "loop", NULL
28554 };
28555
28556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28558 if (!SWIG_IsOK(res1)) {
28559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28560 }
28561 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28562 {
28563 PyThreadState* __tstate = wxPyBeginAllowThreads();
28564 wxEventLoop::SetActive(arg1);
28565 wxPyEndAllowThreads(__tstate);
28566 if (PyErr_Occurred()) SWIG_fail;
28567 }
28568 resultobj = SWIG_Py_Void();
28569 return resultobj;
28570 fail:
28571 return NULL;
28572 }
28573
28574
28575 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28576 PyObject *obj;
28577 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28578 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28579 return SWIG_Py_Void();
28580 }
28581
28582 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28583 return SWIG_Python_InitShadowInstance(args);
28584 }
28585
28586 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28587 PyObject *resultobj = 0;
28588 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28589 wxEventLoopActivator *result = 0 ;
28590 void *argp1 = 0 ;
28591 int res1 = 0 ;
28592 PyObject * obj0 = 0 ;
28593 char * kwnames[] = {
28594 (char *) "evtLoop", NULL
28595 };
28596
28597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28599 if (!SWIG_IsOK(res1)) {
28600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28601 }
28602 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28603 {
28604 PyThreadState* __tstate = wxPyBeginAllowThreads();
28605 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28606 wxPyEndAllowThreads(__tstate);
28607 if (PyErr_Occurred()) SWIG_fail;
28608 }
28609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28610 return resultobj;
28611 fail:
28612 return NULL;
28613 }
28614
28615
28616 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28617 PyObject *resultobj = 0;
28618 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28619 void *argp1 = 0 ;
28620 int res1 = 0 ;
28621 PyObject *swig_obj[1] ;
28622
28623 if (!args) SWIG_fail;
28624 swig_obj[0] = args;
28625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28626 if (!SWIG_IsOK(res1)) {
28627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28628 }
28629 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28630 {
28631 PyThreadState* __tstate = wxPyBeginAllowThreads();
28632 delete arg1;
28633
28634 wxPyEndAllowThreads(__tstate);
28635 if (PyErr_Occurred()) SWIG_fail;
28636 }
28637 resultobj = SWIG_Py_Void();
28638 return resultobj;
28639 fail:
28640 return NULL;
28641 }
28642
28643
28644 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28645 PyObject *obj;
28646 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28647 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28648 return SWIG_Py_Void();
28649 }
28650
28651 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28652 return SWIG_Python_InitShadowInstance(args);
28653 }
28654
28655 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28656 PyObject *resultobj = 0;
28657 int arg1 = (int) 0 ;
28658 int arg2 = (int) 0 ;
28659 int arg3 = (int) 0 ;
28660 wxAcceleratorEntry *result = 0 ;
28661 int val1 ;
28662 int ecode1 = 0 ;
28663 int val2 ;
28664 int ecode2 = 0 ;
28665 int val3 ;
28666 int ecode3 = 0 ;
28667 PyObject * obj0 = 0 ;
28668 PyObject * obj1 = 0 ;
28669 PyObject * obj2 = 0 ;
28670 char * kwnames[] = {
28671 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28672 };
28673
28674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28675 if (obj0) {
28676 ecode1 = SWIG_AsVal_int(obj0, &val1);
28677 if (!SWIG_IsOK(ecode1)) {
28678 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28679 }
28680 arg1 = static_cast< int >(val1);
28681 }
28682 if (obj1) {
28683 ecode2 = SWIG_AsVal_int(obj1, &val2);
28684 if (!SWIG_IsOK(ecode2)) {
28685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28686 }
28687 arg2 = static_cast< int >(val2);
28688 }
28689 if (obj2) {
28690 ecode3 = SWIG_AsVal_int(obj2, &val3);
28691 if (!SWIG_IsOK(ecode3)) {
28692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28693 }
28694 arg3 = static_cast< int >(val3);
28695 }
28696 {
28697 PyThreadState* __tstate = wxPyBeginAllowThreads();
28698 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28699 wxPyEndAllowThreads(__tstate);
28700 if (PyErr_Occurred()) SWIG_fail;
28701 }
28702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28703 return resultobj;
28704 fail:
28705 return NULL;
28706 }
28707
28708
28709 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28710 PyObject *resultobj = 0;
28711 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28712 void *argp1 = 0 ;
28713 int res1 = 0 ;
28714 PyObject *swig_obj[1] ;
28715
28716 if (!args) SWIG_fail;
28717 swig_obj[0] = args;
28718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28719 if (!SWIG_IsOK(res1)) {
28720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28721 }
28722 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28723 {
28724 PyThreadState* __tstate = wxPyBeginAllowThreads();
28725 delete arg1;
28726
28727 wxPyEndAllowThreads(__tstate);
28728 if (PyErr_Occurred()) SWIG_fail;
28729 }
28730 resultobj = SWIG_Py_Void();
28731 return resultobj;
28732 fail:
28733 return NULL;
28734 }
28735
28736
28737 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28738 PyObject *resultobj = 0;
28739 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28740 int arg2 ;
28741 int arg3 ;
28742 int arg4 ;
28743 void *argp1 = 0 ;
28744 int res1 = 0 ;
28745 int val2 ;
28746 int ecode2 = 0 ;
28747 int val3 ;
28748 int ecode3 = 0 ;
28749 int val4 ;
28750 int ecode4 = 0 ;
28751 PyObject * obj0 = 0 ;
28752 PyObject * obj1 = 0 ;
28753 PyObject * obj2 = 0 ;
28754 PyObject * obj3 = 0 ;
28755 char * kwnames[] = {
28756 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28757 };
28758
28759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28761 if (!SWIG_IsOK(res1)) {
28762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28763 }
28764 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28765 ecode2 = SWIG_AsVal_int(obj1, &val2);
28766 if (!SWIG_IsOK(ecode2)) {
28767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28768 }
28769 arg2 = static_cast< int >(val2);
28770 ecode3 = SWIG_AsVal_int(obj2, &val3);
28771 if (!SWIG_IsOK(ecode3)) {
28772 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28773 }
28774 arg3 = static_cast< int >(val3);
28775 ecode4 = SWIG_AsVal_int(obj3, &val4);
28776 if (!SWIG_IsOK(ecode4)) {
28777 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28778 }
28779 arg4 = static_cast< int >(val4);
28780 {
28781 PyThreadState* __tstate = wxPyBeginAllowThreads();
28782 (arg1)->Set(arg2,arg3,arg4);
28783 wxPyEndAllowThreads(__tstate);
28784 if (PyErr_Occurred()) SWIG_fail;
28785 }
28786 resultobj = SWIG_Py_Void();
28787 return resultobj;
28788 fail:
28789 return NULL;
28790 }
28791
28792
28793 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28794 PyObject *resultobj = 0;
28795 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28796 int result;
28797 void *argp1 = 0 ;
28798 int res1 = 0 ;
28799 PyObject *swig_obj[1] ;
28800
28801 if (!args) SWIG_fail;
28802 swig_obj[0] = args;
28803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28804 if (!SWIG_IsOK(res1)) {
28805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28806 }
28807 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28808 {
28809 PyThreadState* __tstate = wxPyBeginAllowThreads();
28810 result = (int)(arg1)->GetFlags();
28811 wxPyEndAllowThreads(__tstate);
28812 if (PyErr_Occurred()) SWIG_fail;
28813 }
28814 resultobj = SWIG_From_int(static_cast< int >(result));
28815 return resultobj;
28816 fail:
28817 return NULL;
28818 }
28819
28820
28821 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28822 PyObject *resultobj = 0;
28823 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28824 int result;
28825 void *argp1 = 0 ;
28826 int res1 = 0 ;
28827 PyObject *swig_obj[1] ;
28828
28829 if (!args) SWIG_fail;
28830 swig_obj[0] = args;
28831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28832 if (!SWIG_IsOK(res1)) {
28833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28834 }
28835 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28836 {
28837 PyThreadState* __tstate = wxPyBeginAllowThreads();
28838 result = (int)(arg1)->GetKeyCode();
28839 wxPyEndAllowThreads(__tstate);
28840 if (PyErr_Occurred()) SWIG_fail;
28841 }
28842 resultobj = SWIG_From_int(static_cast< int >(result));
28843 return resultobj;
28844 fail:
28845 return NULL;
28846 }
28847
28848
28849 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28850 PyObject *resultobj = 0;
28851 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28852 int result;
28853 void *argp1 = 0 ;
28854 int res1 = 0 ;
28855 PyObject *swig_obj[1] ;
28856
28857 if (!args) SWIG_fail;
28858 swig_obj[0] = args;
28859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28860 if (!SWIG_IsOK(res1)) {
28861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28862 }
28863 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28864 {
28865 PyThreadState* __tstate = wxPyBeginAllowThreads();
28866 result = (int)(arg1)->GetCommand();
28867 wxPyEndAllowThreads(__tstate);
28868 if (PyErr_Occurred()) SWIG_fail;
28869 }
28870 resultobj = SWIG_From_int(static_cast< int >(result));
28871 return resultobj;
28872 fail:
28873 return NULL;
28874 }
28875
28876
28877 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28878 PyObject *obj;
28879 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28880 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
28881 return SWIG_Py_Void();
28882 }
28883
28884 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28885 return SWIG_Python_InitShadowInstance(args);
28886 }
28887
28888 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28889 PyObject *resultobj = 0;
28890 int arg1 ;
28891 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
28892 wxAcceleratorTable *result = 0 ;
28893 PyObject * obj0 = 0 ;
28894 char * kwnames[] = {
28895 (char *) "n", NULL
28896 };
28897
28898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
28899 {
28900 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
28901 if (arg2) arg1 = PyList_Size(obj0);
28902 else arg1 = 0;
28903 }
28904 {
28905 PyThreadState* __tstate = wxPyBeginAllowThreads();
28906 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
28907 wxPyEndAllowThreads(__tstate);
28908 if (PyErr_Occurred()) SWIG_fail;
28909 }
28910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
28911 return resultobj;
28912 fail:
28913 return NULL;
28914 }
28915
28916
28917 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28918 PyObject *resultobj = 0;
28919 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
28920 void *argp1 = 0 ;
28921 int res1 = 0 ;
28922 PyObject *swig_obj[1] ;
28923
28924 if (!args) SWIG_fail;
28925 swig_obj[0] = args;
28926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
28927 if (!SWIG_IsOK(res1)) {
28928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
28929 }
28930 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
28931 {
28932 PyThreadState* __tstate = wxPyBeginAllowThreads();
28933 delete arg1;
28934
28935 wxPyEndAllowThreads(__tstate);
28936 if (PyErr_Occurred()) SWIG_fail;
28937 }
28938 resultobj = SWIG_Py_Void();
28939 return resultobj;
28940 fail:
28941 return NULL;
28942 }
28943
28944
28945 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28946 PyObject *resultobj = 0;
28947 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
28948 bool result;
28949 void *argp1 = 0 ;
28950 int res1 = 0 ;
28951 PyObject *swig_obj[1] ;
28952
28953 if (!args) SWIG_fail;
28954 swig_obj[0] = args;
28955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
28956 if (!SWIG_IsOK(res1)) {
28957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
28958 }
28959 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
28960 {
28961 PyThreadState* __tstate = wxPyBeginAllowThreads();
28962 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
28963 wxPyEndAllowThreads(__tstate);
28964 if (PyErr_Occurred()) SWIG_fail;
28965 }
28966 {
28967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28968 }
28969 return resultobj;
28970 fail:
28971 return NULL;
28972 }
28973
28974
28975 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28976 PyObject *obj;
28977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28978 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
28979 return SWIG_Py_Void();
28980 }
28981
28982 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28983 return SWIG_Python_InitShadowInstance(args);
28984 }
28985
28986 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
28987 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
28988 return 1;
28989 }
28990
28991
28992 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
28993 PyObject *pyobj = 0;
28994
28995 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
28996 return pyobj;
28997 }
28998
28999
29000 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29001 PyObject *resultobj = 0;
29002 wxString *arg1 = 0 ;
29003 wxAcceleratorEntry *result = 0 ;
29004 bool temp1 = false ;
29005 PyObject * obj0 = 0 ;
29006 char * kwnames[] = {
29007 (char *) "label", NULL
29008 };
29009
29010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29011 {
29012 arg1 = wxString_in_helper(obj0);
29013 if (arg1 == NULL) SWIG_fail;
29014 temp1 = true;
29015 }
29016 {
29017 PyThreadState* __tstate = wxPyBeginAllowThreads();
29018 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29019 wxPyEndAllowThreads(__tstate);
29020 if (PyErr_Occurred()) SWIG_fail;
29021 }
29022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29023 {
29024 if (temp1)
29025 delete arg1;
29026 }
29027 return resultobj;
29028 fail:
29029 {
29030 if (temp1)
29031 delete arg1;
29032 }
29033 return NULL;
29034 }
29035
29036
29037 SWIGINTERN int PanelNameStr_set(PyObject *) {
29038 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29039 return 1;
29040 }
29041
29042
29043 SWIGINTERN PyObject *PanelNameStr_get(void) {
29044 PyObject *pyobj = 0;
29045
29046 {
29047 #if wxUSE_UNICODE
29048 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29049 #else
29050 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29051 #endif
29052 }
29053 return pyobj;
29054 }
29055
29056
29057 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29058 PyObject *resultobj = 0;
29059 wxVisualAttributes *result = 0 ;
29060
29061 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29062 {
29063 PyThreadState* __tstate = wxPyBeginAllowThreads();
29064 result = (wxVisualAttributes *)new_wxVisualAttributes();
29065 wxPyEndAllowThreads(__tstate);
29066 if (PyErr_Occurred()) SWIG_fail;
29067 }
29068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29069 return resultobj;
29070 fail:
29071 return NULL;
29072 }
29073
29074
29075 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29076 PyObject *resultobj = 0;
29077 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29078 void *argp1 = 0 ;
29079 int res1 = 0 ;
29080 PyObject *swig_obj[1] ;
29081
29082 if (!args) SWIG_fail;
29083 swig_obj[0] = args;
29084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29085 if (!SWIG_IsOK(res1)) {
29086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29087 }
29088 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29089 {
29090 PyThreadState* __tstate = wxPyBeginAllowThreads();
29091 delete_wxVisualAttributes(arg1);
29092
29093 wxPyEndAllowThreads(__tstate);
29094 if (PyErr_Occurred()) SWIG_fail;
29095 }
29096 resultobj = SWIG_Py_Void();
29097 return resultobj;
29098 fail:
29099 return NULL;
29100 }
29101
29102
29103 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29104 PyObject *resultobj = 0;
29105 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29106 wxFont *arg2 = (wxFont *) 0 ;
29107 void *argp1 = 0 ;
29108 int res1 = 0 ;
29109 void *argp2 = 0 ;
29110 int res2 = 0 ;
29111 PyObject *swig_obj[2] ;
29112
29113 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29115 if (!SWIG_IsOK(res1)) {
29116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29117 }
29118 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29119 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29120 if (!SWIG_IsOK(res2)) {
29121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29122 }
29123 arg2 = reinterpret_cast< wxFont * >(argp2);
29124 if (arg1) (arg1)->font = *arg2;
29125
29126 resultobj = SWIG_Py_Void();
29127 return resultobj;
29128 fail:
29129 return NULL;
29130 }
29131
29132
29133 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29134 PyObject *resultobj = 0;
29135 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29136 wxFont *result = 0 ;
29137 void *argp1 = 0 ;
29138 int res1 = 0 ;
29139 PyObject *swig_obj[1] ;
29140
29141 if (!args) SWIG_fail;
29142 swig_obj[0] = args;
29143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29144 if (!SWIG_IsOK(res1)) {
29145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29146 }
29147 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29148 result = (wxFont *)& ((arg1)->font);
29149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29150 return resultobj;
29151 fail:
29152 return NULL;
29153 }
29154
29155
29156 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29157 PyObject *resultobj = 0;
29158 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29159 wxColour *arg2 = (wxColour *) 0 ;
29160 void *argp1 = 0 ;
29161 int res1 = 0 ;
29162 void *argp2 = 0 ;
29163 int res2 = 0 ;
29164 PyObject *swig_obj[2] ;
29165
29166 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29168 if (!SWIG_IsOK(res1)) {
29169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29170 }
29171 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29172 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29173 if (!SWIG_IsOK(res2)) {
29174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29175 }
29176 arg2 = reinterpret_cast< wxColour * >(argp2);
29177 if (arg1) (arg1)->colFg = *arg2;
29178
29179 resultobj = SWIG_Py_Void();
29180 return resultobj;
29181 fail:
29182 return NULL;
29183 }
29184
29185
29186 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29187 PyObject *resultobj = 0;
29188 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29189 wxColour *result = 0 ;
29190 void *argp1 = 0 ;
29191 int res1 = 0 ;
29192 PyObject *swig_obj[1] ;
29193
29194 if (!args) SWIG_fail;
29195 swig_obj[0] = args;
29196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29197 if (!SWIG_IsOK(res1)) {
29198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29199 }
29200 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29201 result = (wxColour *)& ((arg1)->colFg);
29202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29203 return resultobj;
29204 fail:
29205 return NULL;
29206 }
29207
29208
29209 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29210 PyObject *resultobj = 0;
29211 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29212 wxColour *arg2 = (wxColour *) 0 ;
29213 void *argp1 = 0 ;
29214 int res1 = 0 ;
29215 void *argp2 = 0 ;
29216 int res2 = 0 ;
29217 PyObject *swig_obj[2] ;
29218
29219 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29221 if (!SWIG_IsOK(res1)) {
29222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29223 }
29224 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29225 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29226 if (!SWIG_IsOK(res2)) {
29227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29228 }
29229 arg2 = reinterpret_cast< wxColour * >(argp2);
29230 if (arg1) (arg1)->colBg = *arg2;
29231
29232 resultobj = SWIG_Py_Void();
29233 return resultobj;
29234 fail:
29235 return NULL;
29236 }
29237
29238
29239 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29240 PyObject *resultobj = 0;
29241 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29242 wxColour *result = 0 ;
29243 void *argp1 = 0 ;
29244 int res1 = 0 ;
29245 PyObject *swig_obj[1] ;
29246
29247 if (!args) SWIG_fail;
29248 swig_obj[0] = args;
29249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29250 if (!SWIG_IsOK(res1)) {
29251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29252 }
29253 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29254 result = (wxColour *)& ((arg1)->colBg);
29255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29256 return resultobj;
29257 fail:
29258 return NULL;
29259 }
29260
29261
29262 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29263 PyObject *obj;
29264 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29265 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29266 return SWIG_Py_Void();
29267 }
29268
29269 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29270 return SWIG_Python_InitShadowInstance(args);
29271 }
29272
29273 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29274 PyObject *resultobj = 0;
29275 wxWindow *arg1 = (wxWindow *) 0 ;
29276 int arg2 = (int) (int)-1 ;
29277 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29278 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29279 wxSize const &arg4_defvalue = wxDefaultSize ;
29280 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29281 long arg5 = (long) 0 ;
29282 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29283 wxString *arg6 = (wxString *) &arg6_defvalue ;
29284 wxWindow *result = 0 ;
29285 void *argp1 = 0 ;
29286 int res1 = 0 ;
29287 int val2 ;
29288 int ecode2 = 0 ;
29289 wxPoint temp3 ;
29290 wxSize temp4 ;
29291 long val5 ;
29292 int ecode5 = 0 ;
29293 bool temp6 = false ;
29294 PyObject * obj0 = 0 ;
29295 PyObject * obj1 = 0 ;
29296 PyObject * obj2 = 0 ;
29297 PyObject * obj3 = 0 ;
29298 PyObject * obj4 = 0 ;
29299 PyObject * obj5 = 0 ;
29300 char * kwnames[] = {
29301 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29302 };
29303
29304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29306 if (!SWIG_IsOK(res1)) {
29307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29308 }
29309 arg1 = reinterpret_cast< wxWindow * >(argp1);
29310 if (obj1) {
29311 ecode2 = SWIG_AsVal_int(obj1, &val2);
29312 if (!SWIG_IsOK(ecode2)) {
29313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29314 }
29315 arg2 = static_cast< int >(val2);
29316 }
29317 if (obj2) {
29318 {
29319 arg3 = &temp3;
29320 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29321 }
29322 }
29323 if (obj3) {
29324 {
29325 arg4 = &temp4;
29326 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29327 }
29328 }
29329 if (obj4) {
29330 ecode5 = SWIG_AsVal_long(obj4, &val5);
29331 if (!SWIG_IsOK(ecode5)) {
29332 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29333 }
29334 arg5 = static_cast< long >(val5);
29335 }
29336 if (obj5) {
29337 {
29338 arg6 = wxString_in_helper(obj5);
29339 if (arg6 == NULL) SWIG_fail;
29340 temp6 = true;
29341 }
29342 }
29343 {
29344 if (!wxPyCheckForApp()) SWIG_fail;
29345 PyThreadState* __tstate = wxPyBeginAllowThreads();
29346 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29347 wxPyEndAllowThreads(__tstate);
29348 if (PyErr_Occurred()) SWIG_fail;
29349 }
29350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29351 {
29352 if (temp6)
29353 delete arg6;
29354 }
29355 return resultobj;
29356 fail:
29357 {
29358 if (temp6)
29359 delete arg6;
29360 }
29361 return NULL;
29362 }
29363
29364
29365 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29366 PyObject *resultobj = 0;
29367 wxWindow *result = 0 ;
29368
29369 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29370 {
29371 if (!wxPyCheckForApp()) SWIG_fail;
29372 PyThreadState* __tstate = wxPyBeginAllowThreads();
29373 result = (wxWindow *)new wxWindow();
29374 wxPyEndAllowThreads(__tstate);
29375 if (PyErr_Occurred()) SWIG_fail;
29376 }
29377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29378 return resultobj;
29379 fail:
29380 return NULL;
29381 }
29382
29383
29384 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29385 PyObject *resultobj = 0;
29386 wxWindow *arg1 = (wxWindow *) 0 ;
29387 wxWindow *arg2 = (wxWindow *) 0 ;
29388 int arg3 = (int) (int)-1 ;
29389 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29390 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29391 wxSize const &arg5_defvalue = wxDefaultSize ;
29392 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29393 long arg6 = (long) 0 ;
29394 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29395 wxString *arg7 = (wxString *) &arg7_defvalue ;
29396 bool result;
29397 void *argp1 = 0 ;
29398 int res1 = 0 ;
29399 void *argp2 = 0 ;
29400 int res2 = 0 ;
29401 int val3 ;
29402 int ecode3 = 0 ;
29403 wxPoint temp4 ;
29404 wxSize temp5 ;
29405 long val6 ;
29406 int ecode6 = 0 ;
29407 bool temp7 = false ;
29408 PyObject * obj0 = 0 ;
29409 PyObject * obj1 = 0 ;
29410 PyObject * obj2 = 0 ;
29411 PyObject * obj3 = 0 ;
29412 PyObject * obj4 = 0 ;
29413 PyObject * obj5 = 0 ;
29414 PyObject * obj6 = 0 ;
29415 char * kwnames[] = {
29416 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29417 };
29418
29419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29421 if (!SWIG_IsOK(res1)) {
29422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29423 }
29424 arg1 = reinterpret_cast< wxWindow * >(argp1);
29425 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29426 if (!SWIG_IsOK(res2)) {
29427 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29428 }
29429 arg2 = reinterpret_cast< wxWindow * >(argp2);
29430 if (obj2) {
29431 ecode3 = SWIG_AsVal_int(obj2, &val3);
29432 if (!SWIG_IsOK(ecode3)) {
29433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29434 }
29435 arg3 = static_cast< int >(val3);
29436 }
29437 if (obj3) {
29438 {
29439 arg4 = &temp4;
29440 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29441 }
29442 }
29443 if (obj4) {
29444 {
29445 arg5 = &temp5;
29446 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29447 }
29448 }
29449 if (obj5) {
29450 ecode6 = SWIG_AsVal_long(obj5, &val6);
29451 if (!SWIG_IsOK(ecode6)) {
29452 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29453 }
29454 arg6 = static_cast< long >(val6);
29455 }
29456 if (obj6) {
29457 {
29458 arg7 = wxString_in_helper(obj6);
29459 if (arg7 == NULL) SWIG_fail;
29460 temp7 = true;
29461 }
29462 }
29463 {
29464 PyThreadState* __tstate = wxPyBeginAllowThreads();
29465 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29466 wxPyEndAllowThreads(__tstate);
29467 if (PyErr_Occurred()) SWIG_fail;
29468 }
29469 {
29470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29471 }
29472 {
29473 if (temp7)
29474 delete arg7;
29475 }
29476 return resultobj;
29477 fail:
29478 {
29479 if (temp7)
29480 delete arg7;
29481 }
29482 return NULL;
29483 }
29484
29485
29486 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29487 PyObject *resultobj = 0;
29488 wxWindow *arg1 = (wxWindow *) 0 ;
29489 bool arg2 = (bool) false ;
29490 bool result;
29491 void *argp1 = 0 ;
29492 int res1 = 0 ;
29493 bool val2 ;
29494 int ecode2 = 0 ;
29495 PyObject * obj0 = 0 ;
29496 PyObject * obj1 = 0 ;
29497 char * kwnames[] = {
29498 (char *) "self",(char *) "force", NULL
29499 };
29500
29501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29503 if (!SWIG_IsOK(res1)) {
29504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29505 }
29506 arg1 = reinterpret_cast< wxWindow * >(argp1);
29507 if (obj1) {
29508 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29509 if (!SWIG_IsOK(ecode2)) {
29510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29511 }
29512 arg2 = static_cast< bool >(val2);
29513 }
29514 {
29515 PyThreadState* __tstate = wxPyBeginAllowThreads();
29516 result = (bool)(arg1)->Close(arg2);
29517 wxPyEndAllowThreads(__tstate);
29518 if (PyErr_Occurred()) SWIG_fail;
29519 }
29520 {
29521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29522 }
29523 return resultobj;
29524 fail:
29525 return NULL;
29526 }
29527
29528
29529 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29530 PyObject *resultobj = 0;
29531 wxWindow *arg1 = (wxWindow *) 0 ;
29532 bool result;
29533 void *argp1 = 0 ;
29534 int res1 = 0 ;
29535 PyObject *swig_obj[1] ;
29536
29537 if (!args) SWIG_fail;
29538 swig_obj[0] = args;
29539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29540 if (!SWIG_IsOK(res1)) {
29541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29542 }
29543 arg1 = reinterpret_cast< wxWindow * >(argp1);
29544 {
29545 PyThreadState* __tstate = wxPyBeginAllowThreads();
29546 result = (bool)(arg1)->Destroy();
29547 wxPyEndAllowThreads(__tstate);
29548 if (PyErr_Occurred()) SWIG_fail;
29549 }
29550 {
29551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29552 }
29553 return resultobj;
29554 fail:
29555 return NULL;
29556 }
29557
29558
29559 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29560 PyObject *resultobj = 0;
29561 wxWindow *arg1 = (wxWindow *) 0 ;
29562 bool result;
29563 void *argp1 = 0 ;
29564 int res1 = 0 ;
29565 PyObject *swig_obj[1] ;
29566
29567 if (!args) SWIG_fail;
29568 swig_obj[0] = args;
29569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29570 if (!SWIG_IsOK(res1)) {
29571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29572 }
29573 arg1 = reinterpret_cast< wxWindow * >(argp1);
29574 {
29575 PyThreadState* __tstate = wxPyBeginAllowThreads();
29576 result = (bool)(arg1)->DestroyChildren();
29577 wxPyEndAllowThreads(__tstate);
29578 if (PyErr_Occurred()) SWIG_fail;
29579 }
29580 {
29581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29582 }
29583 return resultobj;
29584 fail:
29585 return NULL;
29586 }
29587
29588
29589 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29590 PyObject *resultobj = 0;
29591 wxWindow *arg1 = (wxWindow *) 0 ;
29592 bool result;
29593 void *argp1 = 0 ;
29594 int res1 = 0 ;
29595 PyObject *swig_obj[1] ;
29596
29597 if (!args) SWIG_fail;
29598 swig_obj[0] = args;
29599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29600 if (!SWIG_IsOK(res1)) {
29601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29602 }
29603 arg1 = reinterpret_cast< wxWindow * >(argp1);
29604 {
29605 PyThreadState* __tstate = wxPyBeginAllowThreads();
29606 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29607 wxPyEndAllowThreads(__tstate);
29608 if (PyErr_Occurred()) SWIG_fail;
29609 }
29610 {
29611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29612 }
29613 return resultobj;
29614 fail:
29615 return NULL;
29616 }
29617
29618
29619 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29620 PyObject *resultobj = 0;
29621 wxWindow *arg1 = (wxWindow *) 0 ;
29622 wxString *arg2 = 0 ;
29623 void *argp1 = 0 ;
29624 int res1 = 0 ;
29625 bool temp2 = false ;
29626 PyObject * obj0 = 0 ;
29627 PyObject * obj1 = 0 ;
29628 char * kwnames[] = {
29629 (char *) "self",(char *) "label", NULL
29630 };
29631
29632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29634 if (!SWIG_IsOK(res1)) {
29635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29636 }
29637 arg1 = reinterpret_cast< wxWindow * >(argp1);
29638 {
29639 arg2 = wxString_in_helper(obj1);
29640 if (arg2 == NULL) SWIG_fail;
29641 temp2 = true;
29642 }
29643 {
29644 PyThreadState* __tstate = wxPyBeginAllowThreads();
29645 (arg1)->SetLabel((wxString const &)*arg2);
29646 wxPyEndAllowThreads(__tstate);
29647 if (PyErr_Occurred()) SWIG_fail;
29648 }
29649 resultobj = SWIG_Py_Void();
29650 {
29651 if (temp2)
29652 delete arg2;
29653 }
29654 return resultobj;
29655 fail:
29656 {
29657 if (temp2)
29658 delete arg2;
29659 }
29660 return NULL;
29661 }
29662
29663
29664 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29665 PyObject *resultobj = 0;
29666 wxWindow *arg1 = (wxWindow *) 0 ;
29667 wxString result;
29668 void *argp1 = 0 ;
29669 int res1 = 0 ;
29670 PyObject *swig_obj[1] ;
29671
29672 if (!args) SWIG_fail;
29673 swig_obj[0] = args;
29674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29675 if (!SWIG_IsOK(res1)) {
29676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29677 }
29678 arg1 = reinterpret_cast< wxWindow * >(argp1);
29679 {
29680 PyThreadState* __tstate = wxPyBeginAllowThreads();
29681 result = ((wxWindow const *)arg1)->GetLabel();
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 {
29686 #if wxUSE_UNICODE
29687 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29688 #else
29689 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29690 #endif
29691 }
29692 return resultobj;
29693 fail:
29694 return NULL;
29695 }
29696
29697
29698 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29699 PyObject *resultobj = 0;
29700 wxWindow *arg1 = (wxWindow *) 0 ;
29701 wxString *arg2 = 0 ;
29702 void *argp1 = 0 ;
29703 int res1 = 0 ;
29704 bool temp2 = false ;
29705 PyObject * obj0 = 0 ;
29706 PyObject * obj1 = 0 ;
29707 char * kwnames[] = {
29708 (char *) "self",(char *) "name", NULL
29709 };
29710
29711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29713 if (!SWIG_IsOK(res1)) {
29714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29715 }
29716 arg1 = reinterpret_cast< wxWindow * >(argp1);
29717 {
29718 arg2 = wxString_in_helper(obj1);
29719 if (arg2 == NULL) SWIG_fail;
29720 temp2 = true;
29721 }
29722 {
29723 PyThreadState* __tstate = wxPyBeginAllowThreads();
29724 (arg1)->SetName((wxString const &)*arg2);
29725 wxPyEndAllowThreads(__tstate);
29726 if (PyErr_Occurred()) SWIG_fail;
29727 }
29728 resultobj = SWIG_Py_Void();
29729 {
29730 if (temp2)
29731 delete arg2;
29732 }
29733 return resultobj;
29734 fail:
29735 {
29736 if (temp2)
29737 delete arg2;
29738 }
29739 return NULL;
29740 }
29741
29742
29743 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29744 PyObject *resultobj = 0;
29745 wxWindow *arg1 = (wxWindow *) 0 ;
29746 wxString result;
29747 void *argp1 = 0 ;
29748 int res1 = 0 ;
29749 PyObject *swig_obj[1] ;
29750
29751 if (!args) SWIG_fail;
29752 swig_obj[0] = args;
29753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29754 if (!SWIG_IsOK(res1)) {
29755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29756 }
29757 arg1 = reinterpret_cast< wxWindow * >(argp1);
29758 {
29759 PyThreadState* __tstate = wxPyBeginAllowThreads();
29760 result = ((wxWindow const *)arg1)->GetName();
29761 wxPyEndAllowThreads(__tstate);
29762 if (PyErr_Occurred()) SWIG_fail;
29763 }
29764 {
29765 #if wxUSE_UNICODE
29766 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29767 #else
29768 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29769 #endif
29770 }
29771 return resultobj;
29772 fail:
29773 return NULL;
29774 }
29775
29776
29777 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29778 PyObject *resultobj = 0;
29779 wxWindow *arg1 = (wxWindow *) 0 ;
29780 wxWindowVariant arg2 ;
29781 void *argp1 = 0 ;
29782 int res1 = 0 ;
29783 int val2 ;
29784 int ecode2 = 0 ;
29785 PyObject * obj0 = 0 ;
29786 PyObject * obj1 = 0 ;
29787 char * kwnames[] = {
29788 (char *) "self",(char *) "variant", NULL
29789 };
29790
29791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29793 if (!SWIG_IsOK(res1)) {
29794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29795 }
29796 arg1 = reinterpret_cast< wxWindow * >(argp1);
29797 ecode2 = SWIG_AsVal_int(obj1, &val2);
29798 if (!SWIG_IsOK(ecode2)) {
29799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29800 }
29801 arg2 = static_cast< wxWindowVariant >(val2);
29802 {
29803 PyThreadState* __tstate = wxPyBeginAllowThreads();
29804 (arg1)->SetWindowVariant(arg2);
29805 wxPyEndAllowThreads(__tstate);
29806 if (PyErr_Occurred()) SWIG_fail;
29807 }
29808 resultobj = SWIG_Py_Void();
29809 return resultobj;
29810 fail:
29811 return NULL;
29812 }
29813
29814
29815 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29816 PyObject *resultobj = 0;
29817 wxWindow *arg1 = (wxWindow *) 0 ;
29818 wxWindowVariant result;
29819 void *argp1 = 0 ;
29820 int res1 = 0 ;
29821 PyObject *swig_obj[1] ;
29822
29823 if (!args) SWIG_fail;
29824 swig_obj[0] = args;
29825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29826 if (!SWIG_IsOK(res1)) {
29827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29828 }
29829 arg1 = reinterpret_cast< wxWindow * >(argp1);
29830 {
29831 PyThreadState* __tstate = wxPyBeginAllowThreads();
29832 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29833 wxPyEndAllowThreads(__tstate);
29834 if (PyErr_Occurred()) SWIG_fail;
29835 }
29836 resultobj = SWIG_From_int(static_cast< int >(result));
29837 return resultobj;
29838 fail:
29839 return NULL;
29840 }
29841
29842
29843 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29844 PyObject *resultobj = 0;
29845 wxWindow *arg1 = (wxWindow *) 0 ;
29846 int arg2 ;
29847 void *argp1 = 0 ;
29848 int res1 = 0 ;
29849 int val2 ;
29850 int ecode2 = 0 ;
29851 PyObject * obj0 = 0 ;
29852 PyObject * obj1 = 0 ;
29853 char * kwnames[] = {
29854 (char *) "self",(char *) "winid", NULL
29855 };
29856
29857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
29858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29859 if (!SWIG_IsOK(res1)) {
29860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
29861 }
29862 arg1 = reinterpret_cast< wxWindow * >(argp1);
29863 ecode2 = SWIG_AsVal_int(obj1, &val2);
29864 if (!SWIG_IsOK(ecode2)) {
29865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
29866 }
29867 arg2 = static_cast< int >(val2);
29868 {
29869 PyThreadState* __tstate = wxPyBeginAllowThreads();
29870 (arg1)->SetId(arg2);
29871 wxPyEndAllowThreads(__tstate);
29872 if (PyErr_Occurred()) SWIG_fail;
29873 }
29874 resultobj = SWIG_Py_Void();
29875 return resultobj;
29876 fail:
29877 return NULL;
29878 }
29879
29880
29881 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29882 PyObject *resultobj = 0;
29883 wxWindow *arg1 = (wxWindow *) 0 ;
29884 int result;
29885 void *argp1 = 0 ;
29886 int res1 = 0 ;
29887 PyObject *swig_obj[1] ;
29888
29889 if (!args) SWIG_fail;
29890 swig_obj[0] = args;
29891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29892 if (!SWIG_IsOK(res1)) {
29893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
29894 }
29895 arg1 = reinterpret_cast< wxWindow * >(argp1);
29896 {
29897 PyThreadState* __tstate = wxPyBeginAllowThreads();
29898 result = (int)((wxWindow const *)arg1)->GetId();
29899 wxPyEndAllowThreads(__tstate);
29900 if (PyErr_Occurred()) SWIG_fail;
29901 }
29902 resultobj = SWIG_From_int(static_cast< int >(result));
29903 return resultobj;
29904 fail:
29905 return NULL;
29906 }
29907
29908
29909 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29910 PyObject *resultobj = 0;
29911 int result;
29912
29913 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
29914 {
29915 PyThreadState* __tstate = wxPyBeginAllowThreads();
29916 result = (int)wxWindow::NewControlId();
29917 wxPyEndAllowThreads(__tstate);
29918 if (PyErr_Occurred()) SWIG_fail;
29919 }
29920 resultobj = SWIG_From_int(static_cast< int >(result));
29921 return resultobj;
29922 fail:
29923 return NULL;
29924 }
29925
29926
29927 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29928 PyObject *resultobj = 0;
29929 int arg1 ;
29930 int result;
29931 int val1 ;
29932 int ecode1 = 0 ;
29933 PyObject * obj0 = 0 ;
29934 char * kwnames[] = {
29935 (char *) "winid", NULL
29936 };
29937
29938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
29939 ecode1 = SWIG_AsVal_int(obj0, &val1);
29940 if (!SWIG_IsOK(ecode1)) {
29941 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
29942 }
29943 arg1 = static_cast< int >(val1);
29944 {
29945 PyThreadState* __tstate = wxPyBeginAllowThreads();
29946 result = (int)wxWindow::NextControlId(arg1);
29947 wxPyEndAllowThreads(__tstate);
29948 if (PyErr_Occurred()) SWIG_fail;
29949 }
29950 resultobj = SWIG_From_int(static_cast< int >(result));
29951 return resultobj;
29952 fail:
29953 return NULL;
29954 }
29955
29956
29957 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29958 PyObject *resultobj = 0;
29959 int arg1 ;
29960 int result;
29961 int val1 ;
29962 int ecode1 = 0 ;
29963 PyObject * obj0 = 0 ;
29964 char * kwnames[] = {
29965 (char *) "winid", NULL
29966 };
29967
29968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
29969 ecode1 = SWIG_AsVal_int(obj0, &val1);
29970 if (!SWIG_IsOK(ecode1)) {
29971 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
29972 }
29973 arg1 = static_cast< int >(val1);
29974 {
29975 PyThreadState* __tstate = wxPyBeginAllowThreads();
29976 result = (int)wxWindow::PrevControlId(arg1);
29977 wxPyEndAllowThreads(__tstate);
29978 if (PyErr_Occurred()) SWIG_fail;
29979 }
29980 resultobj = SWIG_From_int(static_cast< int >(result));
29981 return resultobj;
29982 fail:
29983 return NULL;
29984 }
29985
29986
29987 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29988 PyObject *resultobj = 0;
29989 wxWindow *arg1 = (wxWindow *) 0 ;
29990 wxSize *arg2 = 0 ;
29991 void *argp1 = 0 ;
29992 int res1 = 0 ;
29993 wxSize temp2 ;
29994 PyObject * obj0 = 0 ;
29995 PyObject * obj1 = 0 ;
29996 char * kwnames[] = {
29997 (char *) "self",(char *) "size", NULL
29998 };
29999
30000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30002 if (!SWIG_IsOK(res1)) {
30003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30004 }
30005 arg1 = reinterpret_cast< wxWindow * >(argp1);
30006 {
30007 arg2 = &temp2;
30008 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30009 }
30010 {
30011 PyThreadState* __tstate = wxPyBeginAllowThreads();
30012 (arg1)->SetSize((wxSize const &)*arg2);
30013 wxPyEndAllowThreads(__tstate);
30014 if (PyErr_Occurred()) SWIG_fail;
30015 }
30016 resultobj = SWIG_Py_Void();
30017 return resultobj;
30018 fail:
30019 return NULL;
30020 }
30021
30022
30023 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30024 PyObject *resultobj = 0;
30025 wxWindow *arg1 = (wxWindow *) 0 ;
30026 int arg2 ;
30027 int arg3 ;
30028 int arg4 ;
30029 int arg5 ;
30030 int arg6 = (int) wxSIZE_AUTO ;
30031 void *argp1 = 0 ;
30032 int res1 = 0 ;
30033 int val2 ;
30034 int ecode2 = 0 ;
30035 int val3 ;
30036 int ecode3 = 0 ;
30037 int val4 ;
30038 int ecode4 = 0 ;
30039 int val5 ;
30040 int ecode5 = 0 ;
30041 int val6 ;
30042 int ecode6 = 0 ;
30043 PyObject * obj0 = 0 ;
30044 PyObject * obj1 = 0 ;
30045 PyObject * obj2 = 0 ;
30046 PyObject * obj3 = 0 ;
30047 PyObject * obj4 = 0 ;
30048 PyObject * obj5 = 0 ;
30049 char * kwnames[] = {
30050 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30051 };
30052
30053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30055 if (!SWIG_IsOK(res1)) {
30056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30057 }
30058 arg1 = reinterpret_cast< wxWindow * >(argp1);
30059 ecode2 = SWIG_AsVal_int(obj1, &val2);
30060 if (!SWIG_IsOK(ecode2)) {
30061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30062 }
30063 arg2 = static_cast< int >(val2);
30064 ecode3 = SWIG_AsVal_int(obj2, &val3);
30065 if (!SWIG_IsOK(ecode3)) {
30066 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30067 }
30068 arg3 = static_cast< int >(val3);
30069 ecode4 = SWIG_AsVal_int(obj3, &val4);
30070 if (!SWIG_IsOK(ecode4)) {
30071 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30072 }
30073 arg4 = static_cast< int >(val4);
30074 ecode5 = SWIG_AsVal_int(obj4, &val5);
30075 if (!SWIG_IsOK(ecode5)) {
30076 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30077 }
30078 arg5 = static_cast< int >(val5);
30079 if (obj5) {
30080 ecode6 = SWIG_AsVal_int(obj5, &val6);
30081 if (!SWIG_IsOK(ecode6)) {
30082 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30083 }
30084 arg6 = static_cast< int >(val6);
30085 }
30086 {
30087 PyThreadState* __tstate = wxPyBeginAllowThreads();
30088 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30089 wxPyEndAllowThreads(__tstate);
30090 if (PyErr_Occurred()) SWIG_fail;
30091 }
30092 resultobj = SWIG_Py_Void();
30093 return resultobj;
30094 fail:
30095 return NULL;
30096 }
30097
30098
30099 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30100 PyObject *resultobj = 0;
30101 wxWindow *arg1 = (wxWindow *) 0 ;
30102 wxRect *arg2 = 0 ;
30103 int arg3 = (int) wxSIZE_AUTO ;
30104 void *argp1 = 0 ;
30105 int res1 = 0 ;
30106 wxRect temp2 ;
30107 int val3 ;
30108 int ecode3 = 0 ;
30109 PyObject * obj0 = 0 ;
30110 PyObject * obj1 = 0 ;
30111 PyObject * obj2 = 0 ;
30112 char * kwnames[] = {
30113 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30114 };
30115
30116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30118 if (!SWIG_IsOK(res1)) {
30119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30120 }
30121 arg1 = reinterpret_cast< wxWindow * >(argp1);
30122 {
30123 arg2 = &temp2;
30124 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30125 }
30126 if (obj2) {
30127 ecode3 = SWIG_AsVal_int(obj2, &val3);
30128 if (!SWIG_IsOK(ecode3)) {
30129 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30130 }
30131 arg3 = static_cast< int >(val3);
30132 }
30133 {
30134 PyThreadState* __tstate = wxPyBeginAllowThreads();
30135 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30136 wxPyEndAllowThreads(__tstate);
30137 if (PyErr_Occurred()) SWIG_fail;
30138 }
30139 resultobj = SWIG_Py_Void();
30140 return resultobj;
30141 fail:
30142 return NULL;
30143 }
30144
30145
30146 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30147 PyObject *resultobj = 0;
30148 wxWindow *arg1 = (wxWindow *) 0 ;
30149 int arg2 ;
30150 int arg3 ;
30151 void *argp1 = 0 ;
30152 int res1 = 0 ;
30153 int val2 ;
30154 int ecode2 = 0 ;
30155 int val3 ;
30156 int ecode3 = 0 ;
30157 PyObject * obj0 = 0 ;
30158 PyObject * obj1 = 0 ;
30159 PyObject * obj2 = 0 ;
30160 char * kwnames[] = {
30161 (char *) "self",(char *) "width",(char *) "height", NULL
30162 };
30163
30164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30166 if (!SWIG_IsOK(res1)) {
30167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30168 }
30169 arg1 = reinterpret_cast< wxWindow * >(argp1);
30170 ecode2 = SWIG_AsVal_int(obj1, &val2);
30171 if (!SWIG_IsOK(ecode2)) {
30172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30173 }
30174 arg2 = static_cast< int >(val2);
30175 ecode3 = SWIG_AsVal_int(obj2, &val3);
30176 if (!SWIG_IsOK(ecode3)) {
30177 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30178 }
30179 arg3 = static_cast< int >(val3);
30180 {
30181 PyThreadState* __tstate = wxPyBeginAllowThreads();
30182 (arg1)->SetSize(arg2,arg3);
30183 wxPyEndAllowThreads(__tstate);
30184 if (PyErr_Occurred()) SWIG_fail;
30185 }
30186 resultobj = SWIG_Py_Void();
30187 return resultobj;
30188 fail:
30189 return NULL;
30190 }
30191
30192
30193 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30194 PyObject *resultobj = 0;
30195 wxWindow *arg1 = (wxWindow *) 0 ;
30196 wxPoint *arg2 = 0 ;
30197 int arg3 = (int) wxSIZE_USE_EXISTING ;
30198 void *argp1 = 0 ;
30199 int res1 = 0 ;
30200 wxPoint temp2 ;
30201 int val3 ;
30202 int ecode3 = 0 ;
30203 PyObject * obj0 = 0 ;
30204 PyObject * obj1 = 0 ;
30205 PyObject * obj2 = 0 ;
30206 char * kwnames[] = {
30207 (char *) "self",(char *) "pt",(char *) "flags", NULL
30208 };
30209
30210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30212 if (!SWIG_IsOK(res1)) {
30213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30214 }
30215 arg1 = reinterpret_cast< wxWindow * >(argp1);
30216 {
30217 arg2 = &temp2;
30218 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30219 }
30220 if (obj2) {
30221 ecode3 = SWIG_AsVal_int(obj2, &val3);
30222 if (!SWIG_IsOK(ecode3)) {
30223 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30224 }
30225 arg3 = static_cast< int >(val3);
30226 }
30227 {
30228 PyThreadState* __tstate = wxPyBeginAllowThreads();
30229 (arg1)->Move((wxPoint const &)*arg2,arg3);
30230 wxPyEndAllowThreads(__tstate);
30231 if (PyErr_Occurred()) SWIG_fail;
30232 }
30233 resultobj = SWIG_Py_Void();
30234 return resultobj;
30235 fail:
30236 return NULL;
30237 }
30238
30239
30240 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30241 PyObject *resultobj = 0;
30242 wxWindow *arg1 = (wxWindow *) 0 ;
30243 int arg2 ;
30244 int arg3 ;
30245 int arg4 = (int) wxSIZE_USE_EXISTING ;
30246 void *argp1 = 0 ;
30247 int res1 = 0 ;
30248 int val2 ;
30249 int ecode2 = 0 ;
30250 int val3 ;
30251 int ecode3 = 0 ;
30252 int val4 ;
30253 int ecode4 = 0 ;
30254 PyObject * obj0 = 0 ;
30255 PyObject * obj1 = 0 ;
30256 PyObject * obj2 = 0 ;
30257 PyObject * obj3 = 0 ;
30258 char * kwnames[] = {
30259 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30260 };
30261
30262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30264 if (!SWIG_IsOK(res1)) {
30265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30266 }
30267 arg1 = reinterpret_cast< wxWindow * >(argp1);
30268 ecode2 = SWIG_AsVal_int(obj1, &val2);
30269 if (!SWIG_IsOK(ecode2)) {
30270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30271 }
30272 arg2 = static_cast< int >(val2);
30273 ecode3 = SWIG_AsVal_int(obj2, &val3);
30274 if (!SWIG_IsOK(ecode3)) {
30275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30276 }
30277 arg3 = static_cast< int >(val3);
30278 if (obj3) {
30279 ecode4 = SWIG_AsVal_int(obj3, &val4);
30280 if (!SWIG_IsOK(ecode4)) {
30281 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30282 }
30283 arg4 = static_cast< int >(val4);
30284 }
30285 {
30286 PyThreadState* __tstate = wxPyBeginAllowThreads();
30287 (arg1)->Move(arg2,arg3,arg4);
30288 wxPyEndAllowThreads(__tstate);
30289 if (PyErr_Occurred()) SWIG_fail;
30290 }
30291 resultobj = SWIG_Py_Void();
30292 return resultobj;
30293 fail:
30294 return NULL;
30295 }
30296
30297
30298 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30299 PyObject *resultobj = 0;
30300 wxWindow *arg1 = (wxWindow *) 0 ;
30301 wxSize const &arg2_defvalue = wxDefaultSize ;
30302 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30303 void *argp1 = 0 ;
30304 int res1 = 0 ;
30305 wxSize temp2 ;
30306 PyObject * obj0 = 0 ;
30307 PyObject * obj1 = 0 ;
30308 char * kwnames[] = {
30309 (char *) "self",(char *) "size", NULL
30310 };
30311
30312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30314 if (!SWIG_IsOK(res1)) {
30315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30316 }
30317 arg1 = reinterpret_cast< wxWindow * >(argp1);
30318 if (obj1) {
30319 {
30320 arg2 = &temp2;
30321 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30322 }
30323 }
30324 {
30325 PyThreadState* __tstate = wxPyBeginAllowThreads();
30326 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30327 wxPyEndAllowThreads(__tstate);
30328 if (PyErr_Occurred()) SWIG_fail;
30329 }
30330 resultobj = SWIG_Py_Void();
30331 return resultobj;
30332 fail:
30333 return NULL;
30334 }
30335
30336
30337 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30338 PyObject *resultobj = 0;
30339 wxWindow *arg1 = (wxWindow *) 0 ;
30340 void *argp1 = 0 ;
30341 int res1 = 0 ;
30342 PyObject *swig_obj[1] ;
30343
30344 if (!args) SWIG_fail;
30345 swig_obj[0] = args;
30346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30347 if (!SWIG_IsOK(res1)) {
30348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30349 }
30350 arg1 = reinterpret_cast< wxWindow * >(argp1);
30351 {
30352 PyThreadState* __tstate = wxPyBeginAllowThreads();
30353 (arg1)->Raise();
30354 wxPyEndAllowThreads(__tstate);
30355 if (PyErr_Occurred()) SWIG_fail;
30356 }
30357 resultobj = SWIG_Py_Void();
30358 return resultobj;
30359 fail:
30360 return NULL;
30361 }
30362
30363
30364 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30365 PyObject *resultobj = 0;
30366 wxWindow *arg1 = (wxWindow *) 0 ;
30367 void *argp1 = 0 ;
30368 int res1 = 0 ;
30369 PyObject *swig_obj[1] ;
30370
30371 if (!args) SWIG_fail;
30372 swig_obj[0] = args;
30373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30374 if (!SWIG_IsOK(res1)) {
30375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30376 }
30377 arg1 = reinterpret_cast< wxWindow * >(argp1);
30378 {
30379 PyThreadState* __tstate = wxPyBeginAllowThreads();
30380 (arg1)->Lower();
30381 wxPyEndAllowThreads(__tstate);
30382 if (PyErr_Occurred()) SWIG_fail;
30383 }
30384 resultobj = SWIG_Py_Void();
30385 return resultobj;
30386 fail:
30387 return NULL;
30388 }
30389
30390
30391 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30392 PyObject *resultobj = 0;
30393 wxWindow *arg1 = (wxWindow *) 0 ;
30394 wxSize *arg2 = 0 ;
30395 void *argp1 = 0 ;
30396 int res1 = 0 ;
30397 wxSize temp2 ;
30398 PyObject * obj0 = 0 ;
30399 PyObject * obj1 = 0 ;
30400 char * kwnames[] = {
30401 (char *) "self",(char *) "size", NULL
30402 };
30403
30404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30406 if (!SWIG_IsOK(res1)) {
30407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30408 }
30409 arg1 = reinterpret_cast< wxWindow * >(argp1);
30410 {
30411 arg2 = &temp2;
30412 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30413 }
30414 {
30415 PyThreadState* __tstate = wxPyBeginAllowThreads();
30416 (arg1)->SetClientSize((wxSize const &)*arg2);
30417 wxPyEndAllowThreads(__tstate);
30418 if (PyErr_Occurred()) SWIG_fail;
30419 }
30420 resultobj = SWIG_Py_Void();
30421 return resultobj;
30422 fail:
30423 return NULL;
30424 }
30425
30426
30427 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30428 PyObject *resultobj = 0;
30429 wxWindow *arg1 = (wxWindow *) 0 ;
30430 int arg2 ;
30431 int arg3 ;
30432 void *argp1 = 0 ;
30433 int res1 = 0 ;
30434 int val2 ;
30435 int ecode2 = 0 ;
30436 int val3 ;
30437 int ecode3 = 0 ;
30438 PyObject * obj0 = 0 ;
30439 PyObject * obj1 = 0 ;
30440 PyObject * obj2 = 0 ;
30441 char * kwnames[] = {
30442 (char *) "self",(char *) "width",(char *) "height", NULL
30443 };
30444
30445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30447 if (!SWIG_IsOK(res1)) {
30448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30449 }
30450 arg1 = reinterpret_cast< wxWindow * >(argp1);
30451 ecode2 = SWIG_AsVal_int(obj1, &val2);
30452 if (!SWIG_IsOK(ecode2)) {
30453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30454 }
30455 arg2 = static_cast< int >(val2);
30456 ecode3 = SWIG_AsVal_int(obj2, &val3);
30457 if (!SWIG_IsOK(ecode3)) {
30458 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30459 }
30460 arg3 = static_cast< int >(val3);
30461 {
30462 PyThreadState* __tstate = wxPyBeginAllowThreads();
30463 (arg1)->SetClientSize(arg2,arg3);
30464 wxPyEndAllowThreads(__tstate);
30465 if (PyErr_Occurred()) SWIG_fail;
30466 }
30467 resultobj = SWIG_Py_Void();
30468 return resultobj;
30469 fail:
30470 return NULL;
30471 }
30472
30473
30474 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30475 PyObject *resultobj = 0;
30476 wxWindow *arg1 = (wxWindow *) 0 ;
30477 wxRect *arg2 = 0 ;
30478 void *argp1 = 0 ;
30479 int res1 = 0 ;
30480 wxRect temp2 ;
30481 PyObject * obj0 = 0 ;
30482 PyObject * obj1 = 0 ;
30483 char * kwnames[] = {
30484 (char *) "self",(char *) "rect", NULL
30485 };
30486
30487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30489 if (!SWIG_IsOK(res1)) {
30490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30491 }
30492 arg1 = reinterpret_cast< wxWindow * >(argp1);
30493 {
30494 arg2 = &temp2;
30495 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30496 }
30497 {
30498 PyThreadState* __tstate = wxPyBeginAllowThreads();
30499 (arg1)->SetClientSize((wxRect const &)*arg2);
30500 wxPyEndAllowThreads(__tstate);
30501 if (PyErr_Occurred()) SWIG_fail;
30502 }
30503 resultobj = SWIG_Py_Void();
30504 return resultobj;
30505 fail:
30506 return NULL;
30507 }
30508
30509
30510 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30511 PyObject *resultobj = 0;
30512 wxWindow *arg1 = (wxWindow *) 0 ;
30513 wxPoint result;
30514 void *argp1 = 0 ;
30515 int res1 = 0 ;
30516 PyObject *swig_obj[1] ;
30517
30518 if (!args) SWIG_fail;
30519 swig_obj[0] = args;
30520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30521 if (!SWIG_IsOK(res1)) {
30522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30523 }
30524 arg1 = reinterpret_cast< wxWindow * >(argp1);
30525 {
30526 PyThreadState* __tstate = wxPyBeginAllowThreads();
30527 result = ((wxWindow const *)arg1)->GetPosition();
30528 wxPyEndAllowThreads(__tstate);
30529 if (PyErr_Occurred()) SWIG_fail;
30530 }
30531 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30532 return resultobj;
30533 fail:
30534 return NULL;
30535 }
30536
30537
30538 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30539 PyObject *resultobj = 0;
30540 wxWindow *arg1 = (wxWindow *) 0 ;
30541 int *arg2 = (int *) 0 ;
30542 int *arg3 = (int *) 0 ;
30543 void *argp1 = 0 ;
30544 int res1 = 0 ;
30545 int temp2 ;
30546 int res2 = SWIG_TMPOBJ ;
30547 int temp3 ;
30548 int res3 = SWIG_TMPOBJ ;
30549 PyObject *swig_obj[1] ;
30550
30551 arg2 = &temp2;
30552 arg3 = &temp3;
30553 if (!args) SWIG_fail;
30554 swig_obj[0] = args;
30555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30556 if (!SWIG_IsOK(res1)) {
30557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30558 }
30559 arg1 = reinterpret_cast< wxWindow * >(argp1);
30560 {
30561 PyThreadState* __tstate = wxPyBeginAllowThreads();
30562 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30563 wxPyEndAllowThreads(__tstate);
30564 if (PyErr_Occurred()) SWIG_fail;
30565 }
30566 resultobj = SWIG_Py_Void();
30567 if (SWIG_IsTmpObj(res2)) {
30568 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30569 } else {
30570 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30571 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30572 }
30573 if (SWIG_IsTmpObj(res3)) {
30574 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30575 } else {
30576 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30577 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30578 }
30579 return resultobj;
30580 fail:
30581 return NULL;
30582 }
30583
30584
30585 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30586 PyObject *resultobj = 0;
30587 wxWindow *arg1 = (wxWindow *) 0 ;
30588 wxPoint result;
30589 void *argp1 = 0 ;
30590 int res1 = 0 ;
30591 PyObject *swig_obj[1] ;
30592
30593 if (!args) SWIG_fail;
30594 swig_obj[0] = args;
30595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30596 if (!SWIG_IsOK(res1)) {
30597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30598 }
30599 arg1 = reinterpret_cast< wxWindow * >(argp1);
30600 {
30601 PyThreadState* __tstate = wxPyBeginAllowThreads();
30602 result = ((wxWindow const *)arg1)->GetScreenPosition();
30603 wxPyEndAllowThreads(__tstate);
30604 if (PyErr_Occurred()) SWIG_fail;
30605 }
30606 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30607 return resultobj;
30608 fail:
30609 return NULL;
30610 }
30611
30612
30613 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30614 PyObject *resultobj = 0;
30615 wxWindow *arg1 = (wxWindow *) 0 ;
30616 int *arg2 = (int *) 0 ;
30617 int *arg3 = (int *) 0 ;
30618 void *argp1 = 0 ;
30619 int res1 = 0 ;
30620 int temp2 ;
30621 int res2 = SWIG_TMPOBJ ;
30622 int temp3 ;
30623 int res3 = SWIG_TMPOBJ ;
30624 PyObject *swig_obj[1] ;
30625
30626 arg2 = &temp2;
30627 arg3 = &temp3;
30628 if (!args) SWIG_fail;
30629 swig_obj[0] = args;
30630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30631 if (!SWIG_IsOK(res1)) {
30632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30633 }
30634 arg1 = reinterpret_cast< wxWindow * >(argp1);
30635 {
30636 PyThreadState* __tstate = wxPyBeginAllowThreads();
30637 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30638 wxPyEndAllowThreads(__tstate);
30639 if (PyErr_Occurred()) SWIG_fail;
30640 }
30641 resultobj = SWIG_Py_Void();
30642 if (SWIG_IsTmpObj(res2)) {
30643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30644 } else {
30645 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30647 }
30648 if (SWIG_IsTmpObj(res3)) {
30649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30650 } else {
30651 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30652 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30653 }
30654 return resultobj;
30655 fail:
30656 return NULL;
30657 }
30658
30659
30660 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30661 PyObject *resultobj = 0;
30662 wxWindow *arg1 = (wxWindow *) 0 ;
30663 wxRect result;
30664 void *argp1 = 0 ;
30665 int res1 = 0 ;
30666 PyObject *swig_obj[1] ;
30667
30668 if (!args) SWIG_fail;
30669 swig_obj[0] = args;
30670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30671 if (!SWIG_IsOK(res1)) {
30672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30673 }
30674 arg1 = reinterpret_cast< wxWindow * >(argp1);
30675 {
30676 PyThreadState* __tstate = wxPyBeginAllowThreads();
30677 result = ((wxWindow const *)arg1)->GetScreenRect();
30678 wxPyEndAllowThreads(__tstate);
30679 if (PyErr_Occurred()) SWIG_fail;
30680 }
30681 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30682 return resultobj;
30683 fail:
30684 return NULL;
30685 }
30686
30687
30688 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30689 PyObject *resultobj = 0;
30690 wxWindow *arg1 = (wxWindow *) 0 ;
30691 wxSize result;
30692 void *argp1 = 0 ;
30693 int res1 = 0 ;
30694 PyObject *swig_obj[1] ;
30695
30696 if (!args) SWIG_fail;
30697 swig_obj[0] = args;
30698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30699 if (!SWIG_IsOK(res1)) {
30700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30701 }
30702 arg1 = reinterpret_cast< wxWindow * >(argp1);
30703 {
30704 PyThreadState* __tstate = wxPyBeginAllowThreads();
30705 result = ((wxWindow const *)arg1)->GetSize();
30706 wxPyEndAllowThreads(__tstate);
30707 if (PyErr_Occurred()) SWIG_fail;
30708 }
30709 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30710 return resultobj;
30711 fail:
30712 return NULL;
30713 }
30714
30715
30716 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30717 PyObject *resultobj = 0;
30718 wxWindow *arg1 = (wxWindow *) 0 ;
30719 int *arg2 = (int *) 0 ;
30720 int *arg3 = (int *) 0 ;
30721 void *argp1 = 0 ;
30722 int res1 = 0 ;
30723 int temp2 ;
30724 int res2 = SWIG_TMPOBJ ;
30725 int temp3 ;
30726 int res3 = SWIG_TMPOBJ ;
30727 PyObject *swig_obj[1] ;
30728
30729 arg2 = &temp2;
30730 arg3 = &temp3;
30731 if (!args) SWIG_fail;
30732 swig_obj[0] = args;
30733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30734 if (!SWIG_IsOK(res1)) {
30735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30736 }
30737 arg1 = reinterpret_cast< wxWindow * >(argp1);
30738 {
30739 PyThreadState* __tstate = wxPyBeginAllowThreads();
30740 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30741 wxPyEndAllowThreads(__tstate);
30742 if (PyErr_Occurred()) SWIG_fail;
30743 }
30744 resultobj = SWIG_Py_Void();
30745 if (SWIG_IsTmpObj(res2)) {
30746 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30747 } else {
30748 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30749 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30750 }
30751 if (SWIG_IsTmpObj(res3)) {
30752 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30753 } else {
30754 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30755 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30756 }
30757 return resultobj;
30758 fail:
30759 return NULL;
30760 }
30761
30762
30763 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30764 PyObject *resultobj = 0;
30765 wxWindow *arg1 = (wxWindow *) 0 ;
30766 wxRect result;
30767 void *argp1 = 0 ;
30768 int res1 = 0 ;
30769 PyObject *swig_obj[1] ;
30770
30771 if (!args) SWIG_fail;
30772 swig_obj[0] = args;
30773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30774 if (!SWIG_IsOK(res1)) {
30775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30776 }
30777 arg1 = reinterpret_cast< wxWindow * >(argp1);
30778 {
30779 PyThreadState* __tstate = wxPyBeginAllowThreads();
30780 result = ((wxWindow const *)arg1)->GetRect();
30781 wxPyEndAllowThreads(__tstate);
30782 if (PyErr_Occurred()) SWIG_fail;
30783 }
30784 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30785 return resultobj;
30786 fail:
30787 return NULL;
30788 }
30789
30790
30791 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30792 PyObject *resultobj = 0;
30793 wxWindow *arg1 = (wxWindow *) 0 ;
30794 wxSize result;
30795 void *argp1 = 0 ;
30796 int res1 = 0 ;
30797 PyObject *swig_obj[1] ;
30798
30799 if (!args) SWIG_fail;
30800 swig_obj[0] = args;
30801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30802 if (!SWIG_IsOK(res1)) {
30803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30804 }
30805 arg1 = reinterpret_cast< wxWindow * >(argp1);
30806 {
30807 PyThreadState* __tstate = wxPyBeginAllowThreads();
30808 result = ((wxWindow const *)arg1)->GetClientSize();
30809 wxPyEndAllowThreads(__tstate);
30810 if (PyErr_Occurred()) SWIG_fail;
30811 }
30812 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30813 return resultobj;
30814 fail:
30815 return NULL;
30816 }
30817
30818
30819 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30820 PyObject *resultobj = 0;
30821 wxWindow *arg1 = (wxWindow *) 0 ;
30822 int *arg2 = (int *) 0 ;
30823 int *arg3 = (int *) 0 ;
30824 void *argp1 = 0 ;
30825 int res1 = 0 ;
30826 int temp2 ;
30827 int res2 = SWIG_TMPOBJ ;
30828 int temp3 ;
30829 int res3 = SWIG_TMPOBJ ;
30830 PyObject *swig_obj[1] ;
30831
30832 arg2 = &temp2;
30833 arg3 = &temp3;
30834 if (!args) SWIG_fail;
30835 swig_obj[0] = args;
30836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30837 if (!SWIG_IsOK(res1)) {
30838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30839 }
30840 arg1 = reinterpret_cast< wxWindow * >(argp1);
30841 {
30842 PyThreadState* __tstate = wxPyBeginAllowThreads();
30843 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30844 wxPyEndAllowThreads(__tstate);
30845 if (PyErr_Occurred()) SWIG_fail;
30846 }
30847 resultobj = SWIG_Py_Void();
30848 if (SWIG_IsTmpObj(res2)) {
30849 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30850 } else {
30851 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30852 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30853 }
30854 if (SWIG_IsTmpObj(res3)) {
30855 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30856 } else {
30857 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30858 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30859 }
30860 return resultobj;
30861 fail:
30862 return NULL;
30863 }
30864
30865
30866 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30867 PyObject *resultobj = 0;
30868 wxWindow *arg1 = (wxWindow *) 0 ;
30869 wxPoint result;
30870 void *argp1 = 0 ;
30871 int res1 = 0 ;
30872 PyObject *swig_obj[1] ;
30873
30874 if (!args) SWIG_fail;
30875 swig_obj[0] = args;
30876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30877 if (!SWIG_IsOK(res1)) {
30878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
30879 }
30880 arg1 = reinterpret_cast< wxWindow * >(argp1);
30881 {
30882 PyThreadState* __tstate = wxPyBeginAllowThreads();
30883 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
30884 wxPyEndAllowThreads(__tstate);
30885 if (PyErr_Occurred()) SWIG_fail;
30886 }
30887 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30888 return resultobj;
30889 fail:
30890 return NULL;
30891 }
30892
30893
30894 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30895 PyObject *resultobj = 0;
30896 wxWindow *arg1 = (wxWindow *) 0 ;
30897 wxRect result;
30898 void *argp1 = 0 ;
30899 int res1 = 0 ;
30900 PyObject *swig_obj[1] ;
30901
30902 if (!args) SWIG_fail;
30903 swig_obj[0] = args;
30904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30905 if (!SWIG_IsOK(res1)) {
30906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30907 }
30908 arg1 = reinterpret_cast< wxWindow * >(argp1);
30909 {
30910 PyThreadState* __tstate = wxPyBeginAllowThreads();
30911 result = ((wxWindow const *)arg1)->GetClientRect();
30912 wxPyEndAllowThreads(__tstate);
30913 if (PyErr_Occurred()) SWIG_fail;
30914 }
30915 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30916 return resultobj;
30917 fail:
30918 return NULL;
30919 }
30920
30921
30922 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30923 PyObject *resultobj = 0;
30924 wxWindow *arg1 = (wxWindow *) 0 ;
30925 wxSize result;
30926 void *argp1 = 0 ;
30927 int res1 = 0 ;
30928 PyObject *swig_obj[1] ;
30929
30930 if (!args) SWIG_fail;
30931 swig_obj[0] = args;
30932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30933 if (!SWIG_IsOK(res1)) {
30934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30935 }
30936 arg1 = reinterpret_cast< wxWindow * >(argp1);
30937 {
30938 PyThreadState* __tstate = wxPyBeginAllowThreads();
30939 result = ((wxWindow const *)arg1)->GetBestSize();
30940 wxPyEndAllowThreads(__tstate);
30941 if (PyErr_Occurred()) SWIG_fail;
30942 }
30943 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30944 return resultobj;
30945 fail:
30946 return NULL;
30947 }
30948
30949
30950 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30951 PyObject *resultobj = 0;
30952 wxWindow *arg1 = (wxWindow *) 0 ;
30953 int *arg2 = (int *) 0 ;
30954 int *arg3 = (int *) 0 ;
30955 void *argp1 = 0 ;
30956 int res1 = 0 ;
30957 int temp2 ;
30958 int res2 = SWIG_TMPOBJ ;
30959 int temp3 ;
30960 int res3 = SWIG_TMPOBJ ;
30961 PyObject *swig_obj[1] ;
30962
30963 arg2 = &temp2;
30964 arg3 = &temp3;
30965 if (!args) SWIG_fail;
30966 swig_obj[0] = args;
30967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30968 if (!SWIG_IsOK(res1)) {
30969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30970 }
30971 arg1 = reinterpret_cast< wxWindow * >(argp1);
30972 {
30973 PyThreadState* __tstate = wxPyBeginAllowThreads();
30974 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
30975 wxPyEndAllowThreads(__tstate);
30976 if (PyErr_Occurred()) SWIG_fail;
30977 }
30978 resultobj = SWIG_Py_Void();
30979 if (SWIG_IsTmpObj(res2)) {
30980 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30981 } else {
30982 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30983 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30984 }
30985 if (SWIG_IsTmpObj(res3)) {
30986 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30987 } else {
30988 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30990 }
30991 return resultobj;
30992 fail:
30993 return NULL;
30994 }
30995
30996
30997 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30998 PyObject *resultobj = 0;
30999 wxWindow *arg1 = (wxWindow *) 0 ;
31000 void *argp1 = 0 ;
31001 int res1 = 0 ;
31002 PyObject *swig_obj[1] ;
31003
31004 if (!args) SWIG_fail;
31005 swig_obj[0] = args;
31006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31007 if (!SWIG_IsOK(res1)) {
31008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31009 }
31010 arg1 = reinterpret_cast< wxWindow * >(argp1);
31011 {
31012 PyThreadState* __tstate = wxPyBeginAllowThreads();
31013 (arg1)->InvalidateBestSize();
31014 wxPyEndAllowThreads(__tstate);
31015 if (PyErr_Occurred()) SWIG_fail;
31016 }
31017 resultobj = SWIG_Py_Void();
31018 return resultobj;
31019 fail:
31020 return NULL;
31021 }
31022
31023
31024 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31025 PyObject *resultobj = 0;
31026 wxWindow *arg1 = (wxWindow *) 0 ;
31027 wxSize *arg2 = 0 ;
31028 void *argp1 = 0 ;
31029 int res1 = 0 ;
31030 wxSize temp2 ;
31031 PyObject * obj0 = 0 ;
31032 PyObject * obj1 = 0 ;
31033 char * kwnames[] = {
31034 (char *) "self",(char *) "size", NULL
31035 };
31036
31037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31039 if (!SWIG_IsOK(res1)) {
31040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31041 }
31042 arg1 = reinterpret_cast< wxWindow * >(argp1);
31043 {
31044 arg2 = &temp2;
31045 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31046 }
31047 {
31048 PyThreadState* __tstate = wxPyBeginAllowThreads();
31049 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31050 wxPyEndAllowThreads(__tstate);
31051 if (PyErr_Occurred()) SWIG_fail;
31052 }
31053 resultobj = SWIG_Py_Void();
31054 return resultobj;
31055 fail:
31056 return NULL;
31057 }
31058
31059
31060 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31061 PyObject *resultobj = 0;
31062 wxWindow *arg1 = (wxWindow *) 0 ;
31063 wxSize result;
31064 void *argp1 = 0 ;
31065 int res1 = 0 ;
31066 PyObject *swig_obj[1] ;
31067
31068 if (!args) SWIG_fail;
31069 swig_obj[0] = args;
31070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31071 if (!SWIG_IsOK(res1)) {
31072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31073 }
31074 arg1 = reinterpret_cast< wxWindow * >(argp1);
31075 {
31076 PyThreadState* __tstate = wxPyBeginAllowThreads();
31077 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31078 wxPyEndAllowThreads(__tstate);
31079 if (PyErr_Occurred()) SWIG_fail;
31080 }
31081 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31082 return resultobj;
31083 fail:
31084 return NULL;
31085 }
31086
31087
31088 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31089 PyObject *resultobj = 0;
31090 wxWindow *arg1 = (wxWindow *) 0 ;
31091 wxSize result;
31092 void *argp1 = 0 ;
31093 int res1 = 0 ;
31094 PyObject *swig_obj[1] ;
31095
31096 if (!args) SWIG_fail;
31097 swig_obj[0] = args;
31098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31099 if (!SWIG_IsOK(res1)) {
31100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31101 }
31102 arg1 = reinterpret_cast< wxWindow * >(argp1);
31103 {
31104 PyThreadState* __tstate = wxPyBeginAllowThreads();
31105 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31106 wxPyEndAllowThreads(__tstate);
31107 if (PyErr_Occurred()) SWIG_fail;
31108 }
31109 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31110 return resultobj;
31111 fail:
31112 return NULL;
31113 }
31114
31115
31116 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31117 PyObject *resultobj = 0;
31118 wxWindow *arg1 = (wxWindow *) 0 ;
31119 int arg2 = (int) wxBOTH ;
31120 void *argp1 = 0 ;
31121 int res1 = 0 ;
31122 int val2 ;
31123 int ecode2 = 0 ;
31124 PyObject * obj0 = 0 ;
31125 PyObject * obj1 = 0 ;
31126 char * kwnames[] = {
31127 (char *) "self",(char *) "direction", NULL
31128 };
31129
31130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31132 if (!SWIG_IsOK(res1)) {
31133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31134 }
31135 arg1 = reinterpret_cast< wxWindow * >(argp1);
31136 if (obj1) {
31137 ecode2 = SWIG_AsVal_int(obj1, &val2);
31138 if (!SWIG_IsOK(ecode2)) {
31139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31140 }
31141 arg2 = static_cast< int >(val2);
31142 }
31143 {
31144 PyThreadState* __tstate = wxPyBeginAllowThreads();
31145 (arg1)->Center(arg2);
31146 wxPyEndAllowThreads(__tstate);
31147 if (PyErr_Occurred()) SWIG_fail;
31148 }
31149 resultobj = SWIG_Py_Void();
31150 return resultobj;
31151 fail:
31152 return NULL;
31153 }
31154
31155
31156 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31157 PyObject *resultobj = 0;
31158 wxWindow *arg1 = (wxWindow *) 0 ;
31159 int arg2 = (int) wxBOTH ;
31160 void *argp1 = 0 ;
31161 int res1 = 0 ;
31162 int val2 ;
31163 int ecode2 = 0 ;
31164 PyObject * obj0 = 0 ;
31165 PyObject * obj1 = 0 ;
31166 char * kwnames[] = {
31167 (char *) "self",(char *) "dir", NULL
31168 };
31169
31170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31172 if (!SWIG_IsOK(res1)) {
31173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31174 }
31175 arg1 = reinterpret_cast< wxWindow * >(argp1);
31176 if (obj1) {
31177 ecode2 = SWIG_AsVal_int(obj1, &val2);
31178 if (!SWIG_IsOK(ecode2)) {
31179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31180 }
31181 arg2 = static_cast< int >(val2);
31182 }
31183 {
31184 PyThreadState* __tstate = wxPyBeginAllowThreads();
31185 (arg1)->CenterOnParent(arg2);
31186 wxPyEndAllowThreads(__tstate);
31187 if (PyErr_Occurred()) SWIG_fail;
31188 }
31189 resultobj = SWIG_Py_Void();
31190 return resultobj;
31191 fail:
31192 return NULL;
31193 }
31194
31195
31196 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31197 PyObject *resultobj = 0;
31198 wxWindow *arg1 = (wxWindow *) 0 ;
31199 void *argp1 = 0 ;
31200 int res1 = 0 ;
31201 PyObject *swig_obj[1] ;
31202
31203 if (!args) SWIG_fail;
31204 swig_obj[0] = args;
31205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31206 if (!SWIG_IsOK(res1)) {
31207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31208 }
31209 arg1 = reinterpret_cast< wxWindow * >(argp1);
31210 {
31211 PyThreadState* __tstate = wxPyBeginAllowThreads();
31212 (arg1)->Fit();
31213 wxPyEndAllowThreads(__tstate);
31214 if (PyErr_Occurred()) SWIG_fail;
31215 }
31216 resultobj = SWIG_Py_Void();
31217 return resultobj;
31218 fail:
31219 return NULL;
31220 }
31221
31222
31223 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31224 PyObject *resultobj = 0;
31225 wxWindow *arg1 = (wxWindow *) 0 ;
31226 void *argp1 = 0 ;
31227 int res1 = 0 ;
31228 PyObject *swig_obj[1] ;
31229
31230 if (!args) SWIG_fail;
31231 swig_obj[0] = args;
31232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31233 if (!SWIG_IsOK(res1)) {
31234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31235 }
31236 arg1 = reinterpret_cast< wxWindow * >(argp1);
31237 {
31238 PyThreadState* __tstate = wxPyBeginAllowThreads();
31239 (arg1)->FitInside();
31240 wxPyEndAllowThreads(__tstate);
31241 if (PyErr_Occurred()) SWIG_fail;
31242 }
31243 resultobj = SWIG_Py_Void();
31244 return resultobj;
31245 fail:
31246 return NULL;
31247 }
31248
31249
31250 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31251 PyObject *resultobj = 0;
31252 wxWindow *arg1 = (wxWindow *) 0 ;
31253 int arg2 ;
31254 int arg3 ;
31255 int arg4 = (int) -1 ;
31256 int arg5 = (int) -1 ;
31257 int arg6 = (int) -1 ;
31258 int arg7 = (int) -1 ;
31259 void *argp1 = 0 ;
31260 int res1 = 0 ;
31261 int val2 ;
31262 int ecode2 = 0 ;
31263 int val3 ;
31264 int ecode3 = 0 ;
31265 int val4 ;
31266 int ecode4 = 0 ;
31267 int val5 ;
31268 int ecode5 = 0 ;
31269 int val6 ;
31270 int ecode6 = 0 ;
31271 int val7 ;
31272 int ecode7 = 0 ;
31273 PyObject * obj0 = 0 ;
31274 PyObject * obj1 = 0 ;
31275 PyObject * obj2 = 0 ;
31276 PyObject * obj3 = 0 ;
31277 PyObject * obj4 = 0 ;
31278 PyObject * obj5 = 0 ;
31279 PyObject * obj6 = 0 ;
31280 char * kwnames[] = {
31281 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31282 };
31283
31284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31286 if (!SWIG_IsOK(res1)) {
31287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31288 }
31289 arg1 = reinterpret_cast< wxWindow * >(argp1);
31290 ecode2 = SWIG_AsVal_int(obj1, &val2);
31291 if (!SWIG_IsOK(ecode2)) {
31292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31293 }
31294 arg2 = static_cast< int >(val2);
31295 ecode3 = SWIG_AsVal_int(obj2, &val3);
31296 if (!SWIG_IsOK(ecode3)) {
31297 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31298 }
31299 arg3 = static_cast< int >(val3);
31300 if (obj3) {
31301 ecode4 = SWIG_AsVal_int(obj3, &val4);
31302 if (!SWIG_IsOK(ecode4)) {
31303 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31304 }
31305 arg4 = static_cast< int >(val4);
31306 }
31307 if (obj4) {
31308 ecode5 = SWIG_AsVal_int(obj4, &val5);
31309 if (!SWIG_IsOK(ecode5)) {
31310 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31311 }
31312 arg5 = static_cast< int >(val5);
31313 }
31314 if (obj5) {
31315 ecode6 = SWIG_AsVal_int(obj5, &val6);
31316 if (!SWIG_IsOK(ecode6)) {
31317 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31318 }
31319 arg6 = static_cast< int >(val6);
31320 }
31321 if (obj6) {
31322 ecode7 = SWIG_AsVal_int(obj6, &val7);
31323 if (!SWIG_IsOK(ecode7)) {
31324 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31325 }
31326 arg7 = static_cast< int >(val7);
31327 }
31328 {
31329 PyThreadState* __tstate = wxPyBeginAllowThreads();
31330 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31331 wxPyEndAllowThreads(__tstate);
31332 if (PyErr_Occurred()) SWIG_fail;
31333 }
31334 resultobj = SWIG_Py_Void();
31335 return resultobj;
31336 fail:
31337 return NULL;
31338 }
31339
31340
31341 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31342 PyObject *resultobj = 0;
31343 wxWindow *arg1 = (wxWindow *) 0 ;
31344 wxSize *arg2 = 0 ;
31345 wxSize const &arg3_defvalue = wxDefaultSize ;
31346 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31347 wxSize const &arg4_defvalue = wxDefaultSize ;
31348 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31349 void *argp1 = 0 ;
31350 int res1 = 0 ;
31351 wxSize temp2 ;
31352 wxSize temp3 ;
31353 wxSize temp4 ;
31354 PyObject * obj0 = 0 ;
31355 PyObject * obj1 = 0 ;
31356 PyObject * obj2 = 0 ;
31357 PyObject * obj3 = 0 ;
31358 char * kwnames[] = {
31359 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31360 };
31361
31362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31364 if (!SWIG_IsOK(res1)) {
31365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31366 }
31367 arg1 = reinterpret_cast< wxWindow * >(argp1);
31368 {
31369 arg2 = &temp2;
31370 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31371 }
31372 if (obj2) {
31373 {
31374 arg3 = &temp3;
31375 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31376 }
31377 }
31378 if (obj3) {
31379 {
31380 arg4 = &temp4;
31381 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31382 }
31383 }
31384 {
31385 PyThreadState* __tstate = wxPyBeginAllowThreads();
31386 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31387 wxPyEndAllowThreads(__tstate);
31388 if (PyErr_Occurred()) SWIG_fail;
31389 }
31390 resultobj = SWIG_Py_Void();
31391 return resultobj;
31392 fail:
31393 return NULL;
31394 }
31395
31396
31397 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31398 PyObject *resultobj = 0;
31399 wxWindow *arg1 = (wxWindow *) 0 ;
31400 int arg2 ;
31401 int arg3 ;
31402 int arg4 = (int) -1 ;
31403 int arg5 = (int) -1 ;
31404 void *argp1 = 0 ;
31405 int res1 = 0 ;
31406 int val2 ;
31407 int ecode2 = 0 ;
31408 int val3 ;
31409 int ecode3 = 0 ;
31410 int val4 ;
31411 int ecode4 = 0 ;
31412 int val5 ;
31413 int ecode5 = 0 ;
31414 PyObject * obj0 = 0 ;
31415 PyObject * obj1 = 0 ;
31416 PyObject * obj2 = 0 ;
31417 PyObject * obj3 = 0 ;
31418 PyObject * obj4 = 0 ;
31419 char * kwnames[] = {
31420 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31421 };
31422
31423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31425 if (!SWIG_IsOK(res1)) {
31426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31427 }
31428 arg1 = reinterpret_cast< wxWindow * >(argp1);
31429 ecode2 = SWIG_AsVal_int(obj1, &val2);
31430 if (!SWIG_IsOK(ecode2)) {
31431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31432 }
31433 arg2 = static_cast< int >(val2);
31434 ecode3 = SWIG_AsVal_int(obj2, &val3);
31435 if (!SWIG_IsOK(ecode3)) {
31436 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31437 }
31438 arg3 = static_cast< int >(val3);
31439 if (obj3) {
31440 ecode4 = SWIG_AsVal_int(obj3, &val4);
31441 if (!SWIG_IsOK(ecode4)) {
31442 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31443 }
31444 arg4 = static_cast< int >(val4);
31445 }
31446 if (obj4) {
31447 ecode5 = SWIG_AsVal_int(obj4, &val5);
31448 if (!SWIG_IsOK(ecode5)) {
31449 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31450 }
31451 arg5 = static_cast< int >(val5);
31452 }
31453 {
31454 PyThreadState* __tstate = wxPyBeginAllowThreads();
31455 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31456 wxPyEndAllowThreads(__tstate);
31457 if (PyErr_Occurred()) SWIG_fail;
31458 }
31459 resultobj = SWIG_Py_Void();
31460 return resultobj;
31461 fail:
31462 return NULL;
31463 }
31464
31465
31466 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31467 PyObject *resultobj = 0;
31468 wxWindow *arg1 = (wxWindow *) 0 ;
31469 wxSize *arg2 = 0 ;
31470 wxSize const &arg3_defvalue = wxDefaultSize ;
31471 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31472 void *argp1 = 0 ;
31473 int res1 = 0 ;
31474 wxSize temp2 ;
31475 wxSize temp3 ;
31476 PyObject * obj0 = 0 ;
31477 PyObject * obj1 = 0 ;
31478 PyObject * obj2 = 0 ;
31479 char * kwnames[] = {
31480 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31481 };
31482
31483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31485 if (!SWIG_IsOK(res1)) {
31486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31487 }
31488 arg1 = reinterpret_cast< wxWindow * >(argp1);
31489 {
31490 arg2 = &temp2;
31491 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31492 }
31493 if (obj2) {
31494 {
31495 arg3 = &temp3;
31496 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31497 }
31498 }
31499 {
31500 PyThreadState* __tstate = wxPyBeginAllowThreads();
31501 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31502 wxPyEndAllowThreads(__tstate);
31503 if (PyErr_Occurred()) SWIG_fail;
31504 }
31505 resultobj = SWIG_Py_Void();
31506 return resultobj;
31507 fail:
31508 return NULL;
31509 }
31510
31511
31512 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31513 PyObject *resultobj = 0;
31514 wxWindow *arg1 = (wxWindow *) 0 ;
31515 wxSize result;
31516 void *argp1 = 0 ;
31517 int res1 = 0 ;
31518 PyObject *swig_obj[1] ;
31519
31520 if (!args) SWIG_fail;
31521 swig_obj[0] = args;
31522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31523 if (!SWIG_IsOK(res1)) {
31524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31525 }
31526 arg1 = reinterpret_cast< wxWindow * >(argp1);
31527 {
31528 PyThreadState* __tstate = wxPyBeginAllowThreads();
31529 result = ((wxWindow const *)arg1)->GetMaxSize();
31530 wxPyEndAllowThreads(__tstate);
31531 if (PyErr_Occurred()) SWIG_fail;
31532 }
31533 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31534 return resultobj;
31535 fail:
31536 return NULL;
31537 }
31538
31539
31540 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31541 PyObject *resultobj = 0;
31542 wxWindow *arg1 = (wxWindow *) 0 ;
31543 wxSize result;
31544 void *argp1 = 0 ;
31545 int res1 = 0 ;
31546 PyObject *swig_obj[1] ;
31547
31548 if (!args) SWIG_fail;
31549 swig_obj[0] = args;
31550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31551 if (!SWIG_IsOK(res1)) {
31552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31553 }
31554 arg1 = reinterpret_cast< wxWindow * >(argp1);
31555 {
31556 PyThreadState* __tstate = wxPyBeginAllowThreads();
31557 result = ((wxWindow const *)arg1)->GetMinSize();
31558 wxPyEndAllowThreads(__tstate);
31559 if (PyErr_Occurred()) SWIG_fail;
31560 }
31561 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31562 return resultobj;
31563 fail:
31564 return NULL;
31565 }
31566
31567
31568 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31569 PyObject *resultobj = 0;
31570 wxWindow *arg1 = (wxWindow *) 0 ;
31571 wxSize *arg2 = 0 ;
31572 void *argp1 = 0 ;
31573 int res1 = 0 ;
31574 wxSize temp2 ;
31575 PyObject * obj0 = 0 ;
31576 PyObject * obj1 = 0 ;
31577 char * kwnames[] = {
31578 (char *) "self",(char *) "minSize", NULL
31579 };
31580
31581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31583 if (!SWIG_IsOK(res1)) {
31584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31585 }
31586 arg1 = reinterpret_cast< wxWindow * >(argp1);
31587 {
31588 arg2 = &temp2;
31589 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31590 }
31591 {
31592 PyThreadState* __tstate = wxPyBeginAllowThreads();
31593 (arg1)->SetMinSize((wxSize const &)*arg2);
31594 wxPyEndAllowThreads(__tstate);
31595 if (PyErr_Occurred()) SWIG_fail;
31596 }
31597 resultobj = SWIG_Py_Void();
31598 return resultobj;
31599 fail:
31600 return NULL;
31601 }
31602
31603
31604 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31605 PyObject *resultobj = 0;
31606 wxWindow *arg1 = (wxWindow *) 0 ;
31607 wxSize *arg2 = 0 ;
31608 void *argp1 = 0 ;
31609 int res1 = 0 ;
31610 wxSize temp2 ;
31611 PyObject * obj0 = 0 ;
31612 PyObject * obj1 = 0 ;
31613 char * kwnames[] = {
31614 (char *) "self",(char *) "maxSize", NULL
31615 };
31616
31617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31619 if (!SWIG_IsOK(res1)) {
31620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31621 }
31622 arg1 = reinterpret_cast< wxWindow * >(argp1);
31623 {
31624 arg2 = &temp2;
31625 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31626 }
31627 {
31628 PyThreadState* __tstate = wxPyBeginAllowThreads();
31629 (arg1)->SetMaxSize((wxSize const &)*arg2);
31630 wxPyEndAllowThreads(__tstate);
31631 if (PyErr_Occurred()) SWIG_fail;
31632 }
31633 resultobj = SWIG_Py_Void();
31634 return resultobj;
31635 fail:
31636 return NULL;
31637 }
31638
31639
31640 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31641 PyObject *resultobj = 0;
31642 wxWindow *arg1 = (wxWindow *) 0 ;
31643 int result;
31644 void *argp1 = 0 ;
31645 int res1 = 0 ;
31646 PyObject *swig_obj[1] ;
31647
31648 if (!args) SWIG_fail;
31649 swig_obj[0] = args;
31650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31651 if (!SWIG_IsOK(res1)) {
31652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31653 }
31654 arg1 = reinterpret_cast< wxWindow * >(argp1);
31655 {
31656 PyThreadState* __tstate = wxPyBeginAllowThreads();
31657 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31658 wxPyEndAllowThreads(__tstate);
31659 if (PyErr_Occurred()) SWIG_fail;
31660 }
31661 resultobj = SWIG_From_int(static_cast< int >(result));
31662 return resultobj;
31663 fail:
31664 return NULL;
31665 }
31666
31667
31668 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31669 PyObject *resultobj = 0;
31670 wxWindow *arg1 = (wxWindow *) 0 ;
31671 int result;
31672 void *argp1 = 0 ;
31673 int res1 = 0 ;
31674 PyObject *swig_obj[1] ;
31675
31676 if (!args) SWIG_fail;
31677 swig_obj[0] = args;
31678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31679 if (!SWIG_IsOK(res1)) {
31680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31681 }
31682 arg1 = reinterpret_cast< wxWindow * >(argp1);
31683 {
31684 PyThreadState* __tstate = wxPyBeginAllowThreads();
31685 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31686 wxPyEndAllowThreads(__tstate);
31687 if (PyErr_Occurred()) SWIG_fail;
31688 }
31689 resultobj = SWIG_From_int(static_cast< int >(result));
31690 return resultobj;
31691 fail:
31692 return NULL;
31693 }
31694
31695
31696 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31697 PyObject *resultobj = 0;
31698 wxWindow *arg1 = (wxWindow *) 0 ;
31699 int result;
31700 void *argp1 = 0 ;
31701 int res1 = 0 ;
31702 PyObject *swig_obj[1] ;
31703
31704 if (!args) SWIG_fail;
31705 swig_obj[0] = args;
31706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31707 if (!SWIG_IsOK(res1)) {
31708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31709 }
31710 arg1 = reinterpret_cast< wxWindow * >(argp1);
31711 {
31712 PyThreadState* __tstate = wxPyBeginAllowThreads();
31713 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31714 wxPyEndAllowThreads(__tstate);
31715 if (PyErr_Occurred()) SWIG_fail;
31716 }
31717 resultobj = SWIG_From_int(static_cast< int >(result));
31718 return resultobj;
31719 fail:
31720 return NULL;
31721 }
31722
31723
31724 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31725 PyObject *resultobj = 0;
31726 wxWindow *arg1 = (wxWindow *) 0 ;
31727 int result;
31728 void *argp1 = 0 ;
31729 int res1 = 0 ;
31730 PyObject *swig_obj[1] ;
31731
31732 if (!args) SWIG_fail;
31733 swig_obj[0] = args;
31734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31735 if (!SWIG_IsOK(res1)) {
31736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31737 }
31738 arg1 = reinterpret_cast< wxWindow * >(argp1);
31739 {
31740 PyThreadState* __tstate = wxPyBeginAllowThreads();
31741 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31742 wxPyEndAllowThreads(__tstate);
31743 if (PyErr_Occurred()) SWIG_fail;
31744 }
31745 resultobj = SWIG_From_int(static_cast< int >(result));
31746 return resultobj;
31747 fail:
31748 return NULL;
31749 }
31750
31751
31752 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31753 PyObject *resultobj = 0;
31754 wxWindow *arg1 = (wxWindow *) 0 ;
31755 wxSize *arg2 = 0 ;
31756 void *argp1 = 0 ;
31757 int res1 = 0 ;
31758 wxSize temp2 ;
31759 PyObject * obj0 = 0 ;
31760 PyObject * obj1 = 0 ;
31761 char * kwnames[] = {
31762 (char *) "self",(char *) "size", NULL
31763 };
31764
31765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31767 if (!SWIG_IsOK(res1)) {
31768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31769 }
31770 arg1 = reinterpret_cast< wxWindow * >(argp1);
31771 {
31772 arg2 = &temp2;
31773 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31774 }
31775 {
31776 PyThreadState* __tstate = wxPyBeginAllowThreads();
31777 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31778 wxPyEndAllowThreads(__tstate);
31779 if (PyErr_Occurred()) SWIG_fail;
31780 }
31781 resultobj = SWIG_Py_Void();
31782 return resultobj;
31783 fail:
31784 return NULL;
31785 }
31786
31787
31788 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31789 PyObject *resultobj = 0;
31790 wxWindow *arg1 = (wxWindow *) 0 ;
31791 int arg2 ;
31792 int arg3 ;
31793 void *argp1 = 0 ;
31794 int res1 = 0 ;
31795 int val2 ;
31796 int ecode2 = 0 ;
31797 int val3 ;
31798 int ecode3 = 0 ;
31799 PyObject * obj0 = 0 ;
31800 PyObject * obj1 = 0 ;
31801 PyObject * obj2 = 0 ;
31802 char * kwnames[] = {
31803 (char *) "self",(char *) "w",(char *) "h", NULL
31804 };
31805
31806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) 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_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31810 }
31811 arg1 = reinterpret_cast< wxWindow * >(argp1);
31812 ecode2 = SWIG_AsVal_int(obj1, &val2);
31813 if (!SWIG_IsOK(ecode2)) {
31814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31815 }
31816 arg2 = static_cast< int >(val2);
31817 ecode3 = SWIG_AsVal_int(obj2, &val3);
31818 if (!SWIG_IsOK(ecode3)) {
31819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31820 }
31821 arg3 = static_cast< int >(val3);
31822 {
31823 PyThreadState* __tstate = wxPyBeginAllowThreads();
31824 (arg1)->SetVirtualSize(arg2,arg3);
31825 wxPyEndAllowThreads(__tstate);
31826 if (PyErr_Occurred()) SWIG_fail;
31827 }
31828 resultobj = SWIG_Py_Void();
31829 return resultobj;
31830 fail:
31831 return NULL;
31832 }
31833
31834
31835 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31836 PyObject *resultobj = 0;
31837 wxWindow *arg1 = (wxWindow *) 0 ;
31838 wxSize result;
31839 void *argp1 = 0 ;
31840 int res1 = 0 ;
31841 PyObject *swig_obj[1] ;
31842
31843 if (!args) SWIG_fail;
31844 swig_obj[0] = args;
31845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31846 if (!SWIG_IsOK(res1)) {
31847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31848 }
31849 arg1 = reinterpret_cast< wxWindow * >(argp1);
31850 {
31851 PyThreadState* __tstate = wxPyBeginAllowThreads();
31852 result = ((wxWindow const *)arg1)->GetVirtualSize();
31853 wxPyEndAllowThreads(__tstate);
31854 if (PyErr_Occurred()) SWIG_fail;
31855 }
31856 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31857 return resultobj;
31858 fail:
31859 return NULL;
31860 }
31861
31862
31863 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31864 PyObject *resultobj = 0;
31865 wxWindow *arg1 = (wxWindow *) 0 ;
31866 int *arg2 = (int *) 0 ;
31867 int *arg3 = (int *) 0 ;
31868 void *argp1 = 0 ;
31869 int res1 = 0 ;
31870 int temp2 ;
31871 int res2 = SWIG_TMPOBJ ;
31872 int temp3 ;
31873 int res3 = SWIG_TMPOBJ ;
31874 PyObject *swig_obj[1] ;
31875
31876 arg2 = &temp2;
31877 arg3 = &temp3;
31878 if (!args) SWIG_fail;
31879 swig_obj[0] = args;
31880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31881 if (!SWIG_IsOK(res1)) {
31882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31883 }
31884 arg1 = reinterpret_cast< wxWindow * >(argp1);
31885 {
31886 PyThreadState* __tstate = wxPyBeginAllowThreads();
31887 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
31888 wxPyEndAllowThreads(__tstate);
31889 if (PyErr_Occurred()) SWIG_fail;
31890 }
31891 resultobj = SWIG_Py_Void();
31892 if (SWIG_IsTmpObj(res2)) {
31893 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31894 } else {
31895 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31896 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31897 }
31898 if (SWIG_IsTmpObj(res3)) {
31899 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31900 } else {
31901 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31902 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31903 }
31904 return resultobj;
31905 fail:
31906 return NULL;
31907 }
31908
31909
31910 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31911 PyObject *resultobj = 0;
31912 wxWindow *arg1 = (wxWindow *) 0 ;
31913 wxSize result;
31914 void *argp1 = 0 ;
31915 int res1 = 0 ;
31916 PyObject *swig_obj[1] ;
31917
31918 if (!args) SWIG_fail;
31919 swig_obj[0] = args;
31920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31921 if (!SWIG_IsOK(res1)) {
31922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31923 }
31924 arg1 = reinterpret_cast< wxWindow * >(argp1);
31925 {
31926 PyThreadState* __tstate = wxPyBeginAllowThreads();
31927 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
31928 wxPyEndAllowThreads(__tstate);
31929 if (PyErr_Occurred()) SWIG_fail;
31930 }
31931 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31932 return resultobj;
31933 fail:
31934 return NULL;
31935 }
31936
31937
31938 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31939 PyObject *resultobj = 0;
31940 wxWindow *arg1 = (wxWindow *) 0 ;
31941 bool arg2 = (bool) true ;
31942 bool result;
31943 void *argp1 = 0 ;
31944 int res1 = 0 ;
31945 bool val2 ;
31946 int ecode2 = 0 ;
31947 PyObject * obj0 = 0 ;
31948 PyObject * obj1 = 0 ;
31949 char * kwnames[] = {
31950 (char *) "self",(char *) "show", NULL
31951 };
31952
31953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
31954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31955 if (!SWIG_IsOK(res1)) {
31956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
31957 }
31958 arg1 = reinterpret_cast< wxWindow * >(argp1);
31959 if (obj1) {
31960 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31961 if (!SWIG_IsOK(ecode2)) {
31962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
31963 }
31964 arg2 = static_cast< bool >(val2);
31965 }
31966 {
31967 PyThreadState* __tstate = wxPyBeginAllowThreads();
31968 result = (bool)(arg1)->Show(arg2);
31969 wxPyEndAllowThreads(__tstate);
31970 if (PyErr_Occurred()) SWIG_fail;
31971 }
31972 {
31973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31974 }
31975 return resultobj;
31976 fail:
31977 return NULL;
31978 }
31979
31980
31981 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31982 PyObject *resultobj = 0;
31983 wxWindow *arg1 = (wxWindow *) 0 ;
31984 bool result;
31985 void *argp1 = 0 ;
31986 int res1 = 0 ;
31987 PyObject *swig_obj[1] ;
31988
31989 if (!args) SWIG_fail;
31990 swig_obj[0] = args;
31991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31992 if (!SWIG_IsOK(res1)) {
31993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
31994 }
31995 arg1 = reinterpret_cast< wxWindow * >(argp1);
31996 {
31997 PyThreadState* __tstate = wxPyBeginAllowThreads();
31998 result = (bool)(arg1)->Hide();
31999 wxPyEndAllowThreads(__tstate);
32000 if (PyErr_Occurred()) SWIG_fail;
32001 }
32002 {
32003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32004 }
32005 return resultobj;
32006 fail:
32007 return NULL;
32008 }
32009
32010
32011 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32012 PyObject *resultobj = 0;
32013 wxWindow *arg1 = (wxWindow *) 0 ;
32014 bool arg2 = (bool) true ;
32015 bool result;
32016 void *argp1 = 0 ;
32017 int res1 = 0 ;
32018 bool val2 ;
32019 int ecode2 = 0 ;
32020 PyObject * obj0 = 0 ;
32021 PyObject * obj1 = 0 ;
32022 char * kwnames[] = {
32023 (char *) "self",(char *) "enable", NULL
32024 };
32025
32026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32028 if (!SWIG_IsOK(res1)) {
32029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32030 }
32031 arg1 = reinterpret_cast< wxWindow * >(argp1);
32032 if (obj1) {
32033 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32034 if (!SWIG_IsOK(ecode2)) {
32035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32036 }
32037 arg2 = static_cast< bool >(val2);
32038 }
32039 {
32040 PyThreadState* __tstate = wxPyBeginAllowThreads();
32041 result = (bool)(arg1)->Enable(arg2);
32042 wxPyEndAllowThreads(__tstate);
32043 if (PyErr_Occurred()) SWIG_fail;
32044 }
32045 {
32046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32047 }
32048 return resultobj;
32049 fail:
32050 return NULL;
32051 }
32052
32053
32054 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32055 PyObject *resultobj = 0;
32056 wxWindow *arg1 = (wxWindow *) 0 ;
32057 bool result;
32058 void *argp1 = 0 ;
32059 int res1 = 0 ;
32060 PyObject *swig_obj[1] ;
32061
32062 if (!args) SWIG_fail;
32063 swig_obj[0] = args;
32064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32065 if (!SWIG_IsOK(res1)) {
32066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32067 }
32068 arg1 = reinterpret_cast< wxWindow * >(argp1);
32069 {
32070 PyThreadState* __tstate = wxPyBeginAllowThreads();
32071 result = (bool)(arg1)->Disable();
32072 wxPyEndAllowThreads(__tstate);
32073 if (PyErr_Occurred()) SWIG_fail;
32074 }
32075 {
32076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32077 }
32078 return resultobj;
32079 fail:
32080 return NULL;
32081 }
32082
32083
32084 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32085 PyObject *resultobj = 0;
32086 wxWindow *arg1 = (wxWindow *) 0 ;
32087 bool result;
32088 void *argp1 = 0 ;
32089 int res1 = 0 ;
32090 PyObject *swig_obj[1] ;
32091
32092 if (!args) SWIG_fail;
32093 swig_obj[0] = args;
32094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32095 if (!SWIG_IsOK(res1)) {
32096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32097 }
32098 arg1 = reinterpret_cast< wxWindow * >(argp1);
32099 {
32100 PyThreadState* __tstate = wxPyBeginAllowThreads();
32101 result = (bool)((wxWindow const *)arg1)->IsShown();
32102 wxPyEndAllowThreads(__tstate);
32103 if (PyErr_Occurred()) SWIG_fail;
32104 }
32105 {
32106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32107 }
32108 return resultobj;
32109 fail:
32110 return NULL;
32111 }
32112
32113
32114 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32115 PyObject *resultobj = 0;
32116 wxWindow *arg1 = (wxWindow *) 0 ;
32117 bool result;
32118 void *argp1 = 0 ;
32119 int res1 = 0 ;
32120 PyObject *swig_obj[1] ;
32121
32122 if (!args) SWIG_fail;
32123 swig_obj[0] = args;
32124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32125 if (!SWIG_IsOK(res1)) {
32126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32127 }
32128 arg1 = reinterpret_cast< wxWindow * >(argp1);
32129 {
32130 PyThreadState* __tstate = wxPyBeginAllowThreads();
32131 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32132 wxPyEndAllowThreads(__tstate);
32133 if (PyErr_Occurred()) SWIG_fail;
32134 }
32135 {
32136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32137 }
32138 return resultobj;
32139 fail:
32140 return NULL;
32141 }
32142
32143
32144 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32145 PyObject *resultobj = 0;
32146 wxWindow *arg1 = (wxWindow *) 0 ;
32147 long arg2 ;
32148 void *argp1 = 0 ;
32149 int res1 = 0 ;
32150 long val2 ;
32151 int ecode2 = 0 ;
32152 PyObject * obj0 = 0 ;
32153 PyObject * obj1 = 0 ;
32154 char * kwnames[] = {
32155 (char *) "self",(char *) "style", NULL
32156 };
32157
32158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32160 if (!SWIG_IsOK(res1)) {
32161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32162 }
32163 arg1 = reinterpret_cast< wxWindow * >(argp1);
32164 ecode2 = SWIG_AsVal_long(obj1, &val2);
32165 if (!SWIG_IsOK(ecode2)) {
32166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32167 }
32168 arg2 = static_cast< long >(val2);
32169 {
32170 PyThreadState* __tstate = wxPyBeginAllowThreads();
32171 (arg1)->SetWindowStyleFlag(arg2);
32172 wxPyEndAllowThreads(__tstate);
32173 if (PyErr_Occurred()) SWIG_fail;
32174 }
32175 resultobj = SWIG_Py_Void();
32176 return resultobj;
32177 fail:
32178 return NULL;
32179 }
32180
32181
32182 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32183 PyObject *resultobj = 0;
32184 wxWindow *arg1 = (wxWindow *) 0 ;
32185 long result;
32186 void *argp1 = 0 ;
32187 int res1 = 0 ;
32188 PyObject *swig_obj[1] ;
32189
32190 if (!args) SWIG_fail;
32191 swig_obj[0] = args;
32192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32193 if (!SWIG_IsOK(res1)) {
32194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32195 }
32196 arg1 = reinterpret_cast< wxWindow * >(argp1);
32197 {
32198 PyThreadState* __tstate = wxPyBeginAllowThreads();
32199 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32200 wxPyEndAllowThreads(__tstate);
32201 if (PyErr_Occurred()) SWIG_fail;
32202 }
32203 resultobj = SWIG_From_long(static_cast< long >(result));
32204 return resultobj;
32205 fail:
32206 return NULL;
32207 }
32208
32209
32210 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32211 PyObject *resultobj = 0;
32212 wxWindow *arg1 = (wxWindow *) 0 ;
32213 int arg2 ;
32214 bool result;
32215 void *argp1 = 0 ;
32216 int res1 = 0 ;
32217 int val2 ;
32218 int ecode2 = 0 ;
32219 PyObject * obj0 = 0 ;
32220 PyObject * obj1 = 0 ;
32221 char * kwnames[] = {
32222 (char *) "self",(char *) "flag", NULL
32223 };
32224
32225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32227 if (!SWIG_IsOK(res1)) {
32228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32229 }
32230 arg1 = reinterpret_cast< wxWindow * >(argp1);
32231 ecode2 = SWIG_AsVal_int(obj1, &val2);
32232 if (!SWIG_IsOK(ecode2)) {
32233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32234 }
32235 arg2 = static_cast< int >(val2);
32236 {
32237 PyThreadState* __tstate = wxPyBeginAllowThreads();
32238 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32239 wxPyEndAllowThreads(__tstate);
32240 if (PyErr_Occurred()) SWIG_fail;
32241 }
32242 {
32243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32244 }
32245 return resultobj;
32246 fail:
32247 return NULL;
32248 }
32249
32250
32251 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32252 PyObject *resultobj = 0;
32253 wxWindow *arg1 = (wxWindow *) 0 ;
32254 bool result;
32255 void *argp1 = 0 ;
32256 int res1 = 0 ;
32257 PyObject *swig_obj[1] ;
32258
32259 if (!args) SWIG_fail;
32260 swig_obj[0] = args;
32261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32262 if (!SWIG_IsOK(res1)) {
32263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32264 }
32265 arg1 = reinterpret_cast< wxWindow * >(argp1);
32266 {
32267 PyThreadState* __tstate = wxPyBeginAllowThreads();
32268 result = (bool)((wxWindow const *)arg1)->IsRetained();
32269 wxPyEndAllowThreads(__tstate);
32270 if (PyErr_Occurred()) SWIG_fail;
32271 }
32272 {
32273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32274 }
32275 return resultobj;
32276 fail:
32277 return NULL;
32278 }
32279
32280
32281 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32282 PyObject *resultobj = 0;
32283 wxWindow *arg1 = (wxWindow *) 0 ;
32284 long arg2 ;
32285 void *argp1 = 0 ;
32286 int res1 = 0 ;
32287 long val2 ;
32288 int ecode2 = 0 ;
32289 PyObject * obj0 = 0 ;
32290 PyObject * obj1 = 0 ;
32291 char * kwnames[] = {
32292 (char *) "self",(char *) "exStyle", NULL
32293 };
32294
32295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32297 if (!SWIG_IsOK(res1)) {
32298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32299 }
32300 arg1 = reinterpret_cast< wxWindow * >(argp1);
32301 ecode2 = SWIG_AsVal_long(obj1, &val2);
32302 if (!SWIG_IsOK(ecode2)) {
32303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32304 }
32305 arg2 = static_cast< long >(val2);
32306 {
32307 PyThreadState* __tstate = wxPyBeginAllowThreads();
32308 (arg1)->SetExtraStyle(arg2);
32309 wxPyEndAllowThreads(__tstate);
32310 if (PyErr_Occurred()) SWIG_fail;
32311 }
32312 resultobj = SWIG_Py_Void();
32313 return resultobj;
32314 fail:
32315 return NULL;
32316 }
32317
32318
32319 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32320 PyObject *resultobj = 0;
32321 wxWindow *arg1 = (wxWindow *) 0 ;
32322 long result;
32323 void *argp1 = 0 ;
32324 int res1 = 0 ;
32325 PyObject *swig_obj[1] ;
32326
32327 if (!args) SWIG_fail;
32328 swig_obj[0] = args;
32329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32330 if (!SWIG_IsOK(res1)) {
32331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32332 }
32333 arg1 = reinterpret_cast< wxWindow * >(argp1);
32334 {
32335 PyThreadState* __tstate = wxPyBeginAllowThreads();
32336 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32337 wxPyEndAllowThreads(__tstate);
32338 if (PyErr_Occurred()) SWIG_fail;
32339 }
32340 resultobj = SWIG_From_long(static_cast< long >(result));
32341 return resultobj;
32342 fail:
32343 return NULL;
32344 }
32345
32346
32347 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32348 PyObject *resultobj = 0;
32349 wxWindow *arg1 = (wxWindow *) 0 ;
32350 bool arg2 = (bool) true ;
32351 void *argp1 = 0 ;
32352 int res1 = 0 ;
32353 bool val2 ;
32354 int ecode2 = 0 ;
32355 PyObject * obj0 = 0 ;
32356 PyObject * obj1 = 0 ;
32357 char * kwnames[] = {
32358 (char *) "self",(char *) "modal", NULL
32359 };
32360
32361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32363 if (!SWIG_IsOK(res1)) {
32364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32365 }
32366 arg1 = reinterpret_cast< wxWindow * >(argp1);
32367 if (obj1) {
32368 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32369 if (!SWIG_IsOK(ecode2)) {
32370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32371 }
32372 arg2 = static_cast< bool >(val2);
32373 }
32374 {
32375 PyThreadState* __tstate = wxPyBeginAllowThreads();
32376 (arg1)->MakeModal(arg2);
32377 wxPyEndAllowThreads(__tstate);
32378 if (PyErr_Occurred()) SWIG_fail;
32379 }
32380 resultobj = SWIG_Py_Void();
32381 return resultobj;
32382 fail:
32383 return NULL;
32384 }
32385
32386
32387 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32388 PyObject *resultobj = 0;
32389 wxWindow *arg1 = (wxWindow *) 0 ;
32390 bool arg2 ;
32391 void *argp1 = 0 ;
32392 int res1 = 0 ;
32393 bool val2 ;
32394 int ecode2 = 0 ;
32395 PyObject * obj0 = 0 ;
32396 PyObject * obj1 = 0 ;
32397 char * kwnames[] = {
32398 (char *) "self",(char *) "enableTheme", NULL
32399 };
32400
32401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32403 if (!SWIG_IsOK(res1)) {
32404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32405 }
32406 arg1 = reinterpret_cast< wxWindow * >(argp1);
32407 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32408 if (!SWIG_IsOK(ecode2)) {
32409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32410 }
32411 arg2 = static_cast< bool >(val2);
32412 {
32413 PyThreadState* __tstate = wxPyBeginAllowThreads();
32414 (arg1)->SetThemeEnabled(arg2);
32415 wxPyEndAllowThreads(__tstate);
32416 if (PyErr_Occurred()) SWIG_fail;
32417 }
32418 resultobj = SWIG_Py_Void();
32419 return resultobj;
32420 fail:
32421 return NULL;
32422 }
32423
32424
32425 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32426 PyObject *resultobj = 0;
32427 wxWindow *arg1 = (wxWindow *) 0 ;
32428 bool result;
32429 void *argp1 = 0 ;
32430 int res1 = 0 ;
32431 PyObject *swig_obj[1] ;
32432
32433 if (!args) SWIG_fail;
32434 swig_obj[0] = args;
32435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32436 if (!SWIG_IsOK(res1)) {
32437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32438 }
32439 arg1 = reinterpret_cast< wxWindow * >(argp1);
32440 {
32441 PyThreadState* __tstate = wxPyBeginAllowThreads();
32442 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32443 wxPyEndAllowThreads(__tstate);
32444 if (PyErr_Occurred()) SWIG_fail;
32445 }
32446 {
32447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32448 }
32449 return resultobj;
32450 fail:
32451 return NULL;
32452 }
32453
32454
32455 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32456 PyObject *resultobj = 0;
32457 wxWindow *arg1 = (wxWindow *) 0 ;
32458 void *argp1 = 0 ;
32459 int res1 = 0 ;
32460 PyObject *swig_obj[1] ;
32461
32462 if (!args) SWIG_fail;
32463 swig_obj[0] = args;
32464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32465 if (!SWIG_IsOK(res1)) {
32466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32467 }
32468 arg1 = reinterpret_cast< wxWindow * >(argp1);
32469 {
32470 PyThreadState* __tstate = wxPyBeginAllowThreads();
32471 (arg1)->SetFocus();
32472 wxPyEndAllowThreads(__tstate);
32473 if (PyErr_Occurred()) SWIG_fail;
32474 }
32475 resultobj = SWIG_Py_Void();
32476 return resultobj;
32477 fail:
32478 return NULL;
32479 }
32480
32481
32482 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32483 PyObject *resultobj = 0;
32484 wxWindow *arg1 = (wxWindow *) 0 ;
32485 void *argp1 = 0 ;
32486 int res1 = 0 ;
32487 PyObject *swig_obj[1] ;
32488
32489 if (!args) SWIG_fail;
32490 swig_obj[0] = args;
32491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32492 if (!SWIG_IsOK(res1)) {
32493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32494 }
32495 arg1 = reinterpret_cast< wxWindow * >(argp1);
32496 {
32497 PyThreadState* __tstate = wxPyBeginAllowThreads();
32498 (arg1)->SetFocusFromKbd();
32499 wxPyEndAllowThreads(__tstate);
32500 if (PyErr_Occurred()) SWIG_fail;
32501 }
32502 resultobj = SWIG_Py_Void();
32503 return resultobj;
32504 fail:
32505 return NULL;
32506 }
32507
32508
32509 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32510 PyObject *resultobj = 0;
32511 wxWindow *result = 0 ;
32512
32513 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32514 {
32515 if (!wxPyCheckForApp()) SWIG_fail;
32516 PyThreadState* __tstate = wxPyBeginAllowThreads();
32517 result = (wxWindow *)wxWindow::FindFocus();
32518 wxPyEndAllowThreads(__tstate);
32519 if (PyErr_Occurred()) SWIG_fail;
32520 }
32521 {
32522 resultobj = wxPyMake_wxObject(result, 0);
32523 }
32524 return resultobj;
32525 fail:
32526 return NULL;
32527 }
32528
32529
32530 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32531 PyObject *resultobj = 0;
32532 wxWindow *arg1 = (wxWindow *) 0 ;
32533 bool result;
32534 void *argp1 = 0 ;
32535 int res1 = 0 ;
32536 PyObject *swig_obj[1] ;
32537
32538 if (!args) SWIG_fail;
32539 swig_obj[0] = args;
32540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32541 if (!SWIG_IsOK(res1)) {
32542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32543 }
32544 arg1 = reinterpret_cast< wxWindow * >(argp1);
32545 {
32546 PyThreadState* __tstate = wxPyBeginAllowThreads();
32547 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32548 wxPyEndAllowThreads(__tstate);
32549 if (PyErr_Occurred()) SWIG_fail;
32550 }
32551 {
32552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32553 }
32554 return resultobj;
32555 fail:
32556 return NULL;
32557 }
32558
32559
32560 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32561 PyObject *resultobj = 0;
32562 wxWindow *arg1 = (wxWindow *) 0 ;
32563 bool result;
32564 void *argp1 = 0 ;
32565 int res1 = 0 ;
32566 PyObject *swig_obj[1] ;
32567
32568 if (!args) SWIG_fail;
32569 swig_obj[0] = args;
32570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32571 if (!SWIG_IsOK(res1)) {
32572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32573 }
32574 arg1 = reinterpret_cast< wxWindow * >(argp1);
32575 {
32576 PyThreadState* __tstate = wxPyBeginAllowThreads();
32577 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32578 wxPyEndAllowThreads(__tstate);
32579 if (PyErr_Occurred()) SWIG_fail;
32580 }
32581 {
32582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32583 }
32584 return resultobj;
32585 fail:
32586 return NULL;
32587 }
32588
32589
32590 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32591 PyObject *resultobj = 0;
32592 wxWindow *arg1 = (wxWindow *) 0 ;
32593 wxWindow *result = 0 ;
32594 void *argp1 = 0 ;
32595 int res1 = 0 ;
32596 PyObject *swig_obj[1] ;
32597
32598 if (!args) SWIG_fail;
32599 swig_obj[0] = args;
32600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32601 if (!SWIG_IsOK(res1)) {
32602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32603 }
32604 arg1 = reinterpret_cast< wxWindow * >(argp1);
32605 {
32606 PyThreadState* __tstate = wxPyBeginAllowThreads();
32607 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32608 wxPyEndAllowThreads(__tstate);
32609 if (PyErr_Occurred()) SWIG_fail;
32610 }
32611 {
32612 resultobj = wxPyMake_wxObject(result, 0);
32613 }
32614 return resultobj;
32615 fail:
32616 return NULL;
32617 }
32618
32619
32620 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32621 PyObject *resultobj = 0;
32622 wxWindow *arg1 = (wxWindow *) 0 ;
32623 wxWindow *arg2 = (wxWindow *) 0 ;
32624 wxWindow *result = 0 ;
32625 void *argp1 = 0 ;
32626 int res1 = 0 ;
32627 void *argp2 = 0 ;
32628 int res2 = 0 ;
32629 PyObject * obj0 = 0 ;
32630 PyObject * obj1 = 0 ;
32631 char * kwnames[] = {
32632 (char *) "self",(char *) "child", NULL
32633 };
32634
32635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32637 if (!SWIG_IsOK(res1)) {
32638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32639 }
32640 arg1 = reinterpret_cast< wxWindow * >(argp1);
32641 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32642 if (!SWIG_IsOK(res2)) {
32643 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32644 }
32645 arg2 = reinterpret_cast< wxWindow * >(argp2);
32646 {
32647 PyThreadState* __tstate = wxPyBeginAllowThreads();
32648 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32649 wxPyEndAllowThreads(__tstate);
32650 if (PyErr_Occurred()) SWIG_fail;
32651 }
32652 {
32653 resultobj = wxPyMake_wxObject(result, 0);
32654 }
32655 return resultobj;
32656 fail:
32657 return NULL;
32658 }
32659
32660
32661 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32662 PyObject *resultobj = 0;
32663 wxWindow *arg1 = (wxWindow *) 0 ;
32664 wxWindow *arg2 = (wxWindow *) 0 ;
32665 void *argp1 = 0 ;
32666 int res1 = 0 ;
32667 void *argp2 = 0 ;
32668 int res2 = 0 ;
32669 PyObject * obj0 = 0 ;
32670 PyObject * obj1 = 0 ;
32671 char * kwnames[] = {
32672 (char *) "self",(char *) "win", NULL
32673 };
32674
32675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32677 if (!SWIG_IsOK(res1)) {
32678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32679 }
32680 arg1 = reinterpret_cast< wxWindow * >(argp1);
32681 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32682 if (!SWIG_IsOK(res2)) {
32683 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32684 }
32685 arg2 = reinterpret_cast< wxWindow * >(argp2);
32686 {
32687 PyThreadState* __tstate = wxPyBeginAllowThreads();
32688 (arg1)->SetTmpDefaultItem(arg2);
32689 wxPyEndAllowThreads(__tstate);
32690 if (PyErr_Occurred()) SWIG_fail;
32691 }
32692 resultobj = SWIG_Py_Void();
32693 return resultobj;
32694 fail:
32695 return NULL;
32696 }
32697
32698
32699 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32700 PyObject *resultobj = 0;
32701 wxWindow *arg1 = (wxWindow *) 0 ;
32702 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32703 bool result;
32704 void *argp1 = 0 ;
32705 int res1 = 0 ;
32706 int val2 ;
32707 int ecode2 = 0 ;
32708 PyObject * obj0 = 0 ;
32709 PyObject * obj1 = 0 ;
32710 char * kwnames[] = {
32711 (char *) "self",(char *) "flags", NULL
32712 };
32713
32714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32716 if (!SWIG_IsOK(res1)) {
32717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32718 }
32719 arg1 = reinterpret_cast< wxWindow * >(argp1);
32720 if (obj1) {
32721 ecode2 = SWIG_AsVal_int(obj1, &val2);
32722 if (!SWIG_IsOK(ecode2)) {
32723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32724 }
32725 arg2 = static_cast< int >(val2);
32726 }
32727 {
32728 PyThreadState* __tstate = wxPyBeginAllowThreads();
32729 result = (bool)(arg1)->Navigate(arg2);
32730 wxPyEndAllowThreads(__tstate);
32731 if (PyErr_Occurred()) SWIG_fail;
32732 }
32733 {
32734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32735 }
32736 return resultobj;
32737 fail:
32738 return NULL;
32739 }
32740
32741
32742 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32743 PyObject *resultobj = 0;
32744 wxWindow *arg1 = (wxWindow *) 0 ;
32745 wxWindow *arg2 = (wxWindow *) 0 ;
32746 void *argp1 = 0 ;
32747 int res1 = 0 ;
32748 void *argp2 = 0 ;
32749 int res2 = 0 ;
32750 PyObject * obj0 = 0 ;
32751 PyObject * obj1 = 0 ;
32752 char * kwnames[] = {
32753 (char *) "self",(char *) "win", NULL
32754 };
32755
32756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32758 if (!SWIG_IsOK(res1)) {
32759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32760 }
32761 arg1 = reinterpret_cast< wxWindow * >(argp1);
32762 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32763 if (!SWIG_IsOK(res2)) {
32764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32765 }
32766 arg2 = reinterpret_cast< wxWindow * >(argp2);
32767 {
32768 PyThreadState* __tstate = wxPyBeginAllowThreads();
32769 (arg1)->MoveAfterInTabOrder(arg2);
32770 wxPyEndAllowThreads(__tstate);
32771 if (PyErr_Occurred()) SWIG_fail;
32772 }
32773 resultobj = SWIG_Py_Void();
32774 return resultobj;
32775 fail:
32776 return NULL;
32777 }
32778
32779
32780 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32781 PyObject *resultobj = 0;
32782 wxWindow *arg1 = (wxWindow *) 0 ;
32783 wxWindow *arg2 = (wxWindow *) 0 ;
32784 void *argp1 = 0 ;
32785 int res1 = 0 ;
32786 void *argp2 = 0 ;
32787 int res2 = 0 ;
32788 PyObject * obj0 = 0 ;
32789 PyObject * obj1 = 0 ;
32790 char * kwnames[] = {
32791 (char *) "self",(char *) "win", NULL
32792 };
32793
32794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32796 if (!SWIG_IsOK(res1)) {
32797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32798 }
32799 arg1 = reinterpret_cast< wxWindow * >(argp1);
32800 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32801 if (!SWIG_IsOK(res2)) {
32802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32803 }
32804 arg2 = reinterpret_cast< wxWindow * >(argp2);
32805 {
32806 PyThreadState* __tstate = wxPyBeginAllowThreads();
32807 (arg1)->MoveBeforeInTabOrder(arg2);
32808 wxPyEndAllowThreads(__tstate);
32809 if (PyErr_Occurred()) SWIG_fail;
32810 }
32811 resultobj = SWIG_Py_Void();
32812 return resultobj;
32813 fail:
32814 return NULL;
32815 }
32816
32817
32818 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32819 PyObject *resultobj = 0;
32820 wxWindow *arg1 = (wxWindow *) 0 ;
32821 PyObject *result = 0 ;
32822 void *argp1 = 0 ;
32823 int res1 = 0 ;
32824 PyObject *swig_obj[1] ;
32825
32826 if (!args) SWIG_fail;
32827 swig_obj[0] = args;
32828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32829 if (!SWIG_IsOK(res1)) {
32830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32831 }
32832 arg1 = reinterpret_cast< wxWindow * >(argp1);
32833 {
32834 PyThreadState* __tstate = wxPyBeginAllowThreads();
32835 result = (PyObject *)wxWindow_GetChildren(arg1);
32836 wxPyEndAllowThreads(__tstate);
32837 if (PyErr_Occurred()) SWIG_fail;
32838 }
32839 resultobj = result;
32840 return resultobj;
32841 fail:
32842 return NULL;
32843 }
32844
32845
32846 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32847 PyObject *resultobj = 0;
32848 wxWindow *arg1 = (wxWindow *) 0 ;
32849 wxWindow *result = 0 ;
32850 void *argp1 = 0 ;
32851 int res1 = 0 ;
32852 PyObject *swig_obj[1] ;
32853
32854 if (!args) SWIG_fail;
32855 swig_obj[0] = args;
32856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32857 if (!SWIG_IsOK(res1)) {
32858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32859 }
32860 arg1 = reinterpret_cast< wxWindow * >(argp1);
32861 {
32862 PyThreadState* __tstate = wxPyBeginAllowThreads();
32863 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
32864 wxPyEndAllowThreads(__tstate);
32865 if (PyErr_Occurred()) SWIG_fail;
32866 }
32867 {
32868 resultobj = wxPyMake_wxObject(result, 0);
32869 }
32870 return resultobj;
32871 fail:
32872 return NULL;
32873 }
32874
32875
32876 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32877 PyObject *resultobj = 0;
32878 wxWindow *arg1 = (wxWindow *) 0 ;
32879 wxWindow *result = 0 ;
32880 void *argp1 = 0 ;
32881 int res1 = 0 ;
32882 PyObject *swig_obj[1] ;
32883
32884 if (!args) SWIG_fail;
32885 swig_obj[0] = args;
32886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32887 if (!SWIG_IsOK(res1)) {
32888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32889 }
32890 arg1 = reinterpret_cast< wxWindow * >(argp1);
32891 {
32892 PyThreadState* __tstate = wxPyBeginAllowThreads();
32893 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
32894 wxPyEndAllowThreads(__tstate);
32895 if (PyErr_Occurred()) SWIG_fail;
32896 }
32897 {
32898 resultobj = wxPyMake_wxObject(result, 0);
32899 }
32900 return resultobj;
32901 fail:
32902 return NULL;
32903 }
32904
32905
32906 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32907 PyObject *resultobj = 0;
32908 wxWindow *arg1 = (wxWindow *) 0 ;
32909 bool result;
32910 void *argp1 = 0 ;
32911 int res1 = 0 ;
32912 PyObject *swig_obj[1] ;
32913
32914 if (!args) SWIG_fail;
32915 swig_obj[0] = args;
32916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32917 if (!SWIG_IsOK(res1)) {
32918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
32919 }
32920 arg1 = reinterpret_cast< wxWindow * >(argp1);
32921 {
32922 PyThreadState* __tstate = wxPyBeginAllowThreads();
32923 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
32924 wxPyEndAllowThreads(__tstate);
32925 if (PyErr_Occurred()) SWIG_fail;
32926 }
32927 {
32928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32929 }
32930 return resultobj;
32931 fail:
32932 return NULL;
32933 }
32934
32935
32936 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32937 PyObject *resultobj = 0;
32938 wxWindow *arg1 = (wxWindow *) 0 ;
32939 wxWindow *arg2 = (wxWindow *) 0 ;
32940 bool result;
32941 void *argp1 = 0 ;
32942 int res1 = 0 ;
32943 void *argp2 = 0 ;
32944 int res2 = 0 ;
32945 PyObject * obj0 = 0 ;
32946 PyObject * obj1 = 0 ;
32947 char * kwnames[] = {
32948 (char *) "self",(char *) "newParent", NULL
32949 };
32950
32951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
32952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32953 if (!SWIG_IsOK(res1)) {
32954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
32955 }
32956 arg1 = reinterpret_cast< wxWindow * >(argp1);
32957 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32958 if (!SWIG_IsOK(res2)) {
32959 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
32960 }
32961 arg2 = reinterpret_cast< wxWindow * >(argp2);
32962 {
32963 PyThreadState* __tstate = wxPyBeginAllowThreads();
32964 result = (bool)(arg1)->Reparent(arg2);
32965 wxPyEndAllowThreads(__tstate);
32966 if (PyErr_Occurred()) SWIG_fail;
32967 }
32968 {
32969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32970 }
32971 return resultobj;
32972 fail:
32973 return NULL;
32974 }
32975
32976
32977 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32978 PyObject *resultobj = 0;
32979 wxWindow *arg1 = (wxWindow *) 0 ;
32980 wxWindow *arg2 = (wxWindow *) 0 ;
32981 void *argp1 = 0 ;
32982 int res1 = 0 ;
32983 void *argp2 = 0 ;
32984 int res2 = 0 ;
32985 PyObject * obj0 = 0 ;
32986 PyObject * obj1 = 0 ;
32987 char * kwnames[] = {
32988 (char *) "self",(char *) "child", NULL
32989 };
32990
32991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
32992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32993 if (!SWIG_IsOK(res1)) {
32994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
32995 }
32996 arg1 = reinterpret_cast< wxWindow * >(argp1);
32997 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32998 if (!SWIG_IsOK(res2)) {
32999 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33000 }
33001 arg2 = reinterpret_cast< wxWindow * >(argp2);
33002 {
33003 PyThreadState* __tstate = wxPyBeginAllowThreads();
33004 (arg1)->AddChild(arg2);
33005 wxPyEndAllowThreads(__tstate);
33006 if (PyErr_Occurred()) SWIG_fail;
33007 }
33008 resultobj = SWIG_Py_Void();
33009 return resultobj;
33010 fail:
33011 return NULL;
33012 }
33013
33014
33015 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33016 PyObject *resultobj = 0;
33017 wxWindow *arg1 = (wxWindow *) 0 ;
33018 wxWindow *arg2 = (wxWindow *) 0 ;
33019 void *argp1 = 0 ;
33020 int res1 = 0 ;
33021 void *argp2 = 0 ;
33022 int res2 = 0 ;
33023 PyObject * obj0 = 0 ;
33024 PyObject * obj1 = 0 ;
33025 char * kwnames[] = {
33026 (char *) "self",(char *) "child", NULL
33027 };
33028
33029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33031 if (!SWIG_IsOK(res1)) {
33032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33033 }
33034 arg1 = reinterpret_cast< wxWindow * >(argp1);
33035 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33036 if (!SWIG_IsOK(res2)) {
33037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33038 }
33039 arg2 = reinterpret_cast< wxWindow * >(argp2);
33040 {
33041 PyThreadState* __tstate = wxPyBeginAllowThreads();
33042 (arg1)->RemoveChild(arg2);
33043 wxPyEndAllowThreads(__tstate);
33044 if (PyErr_Occurred()) SWIG_fail;
33045 }
33046 resultobj = SWIG_Py_Void();
33047 return resultobj;
33048 fail:
33049 return NULL;
33050 }
33051
33052
33053 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33054 PyObject *resultobj = 0;
33055 wxWindow *arg1 = (wxWindow *) 0 ;
33056 long arg2 ;
33057 wxWindow *result = 0 ;
33058 void *argp1 = 0 ;
33059 int res1 = 0 ;
33060 long val2 ;
33061 int ecode2 = 0 ;
33062 PyObject * obj0 = 0 ;
33063 PyObject * obj1 = 0 ;
33064 char * kwnames[] = {
33065 (char *) "self",(char *) "winid", NULL
33066 };
33067
33068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33070 if (!SWIG_IsOK(res1)) {
33071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33072 }
33073 arg1 = reinterpret_cast< wxWindow * >(argp1);
33074 ecode2 = SWIG_AsVal_long(obj1, &val2);
33075 if (!SWIG_IsOK(ecode2)) {
33076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33077 }
33078 arg2 = static_cast< long >(val2);
33079 {
33080 PyThreadState* __tstate = wxPyBeginAllowThreads();
33081 result = (wxWindow *)(arg1)->FindWindow(arg2);
33082 wxPyEndAllowThreads(__tstate);
33083 if (PyErr_Occurred()) SWIG_fail;
33084 }
33085 {
33086 resultobj = wxPyMake_wxObject(result, 0);
33087 }
33088 return resultobj;
33089 fail:
33090 return NULL;
33091 }
33092
33093
33094 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33095 PyObject *resultobj = 0;
33096 wxWindow *arg1 = (wxWindow *) 0 ;
33097 wxString *arg2 = 0 ;
33098 wxWindow *result = 0 ;
33099 void *argp1 = 0 ;
33100 int res1 = 0 ;
33101 bool temp2 = false ;
33102 PyObject * obj0 = 0 ;
33103 PyObject * obj1 = 0 ;
33104 char * kwnames[] = {
33105 (char *) "self",(char *) "name", NULL
33106 };
33107
33108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33110 if (!SWIG_IsOK(res1)) {
33111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33112 }
33113 arg1 = reinterpret_cast< wxWindow * >(argp1);
33114 {
33115 arg2 = wxString_in_helper(obj1);
33116 if (arg2 == NULL) SWIG_fail;
33117 temp2 = true;
33118 }
33119 {
33120 PyThreadState* __tstate = wxPyBeginAllowThreads();
33121 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33122 wxPyEndAllowThreads(__tstate);
33123 if (PyErr_Occurred()) SWIG_fail;
33124 }
33125 {
33126 resultobj = wxPyMake_wxObject(result, 0);
33127 }
33128 {
33129 if (temp2)
33130 delete arg2;
33131 }
33132 return resultobj;
33133 fail:
33134 {
33135 if (temp2)
33136 delete arg2;
33137 }
33138 return NULL;
33139 }
33140
33141
33142 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33143 PyObject *resultobj = 0;
33144 wxWindow *arg1 = (wxWindow *) 0 ;
33145 wxEvtHandler *result = 0 ;
33146 void *argp1 = 0 ;
33147 int res1 = 0 ;
33148 PyObject *swig_obj[1] ;
33149
33150 if (!args) SWIG_fail;
33151 swig_obj[0] = args;
33152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33153 if (!SWIG_IsOK(res1)) {
33154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33155 }
33156 arg1 = reinterpret_cast< wxWindow * >(argp1);
33157 {
33158 PyThreadState* __tstate = wxPyBeginAllowThreads();
33159 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33160 wxPyEndAllowThreads(__tstate);
33161 if (PyErr_Occurred()) SWIG_fail;
33162 }
33163 {
33164 resultobj = wxPyMake_wxObject(result, 0);
33165 }
33166 return resultobj;
33167 fail:
33168 return NULL;
33169 }
33170
33171
33172 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33173 PyObject *resultobj = 0;
33174 wxWindow *arg1 = (wxWindow *) 0 ;
33175 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33176 void *argp1 = 0 ;
33177 int res1 = 0 ;
33178 void *argp2 = 0 ;
33179 int res2 = 0 ;
33180 PyObject * obj0 = 0 ;
33181 PyObject * obj1 = 0 ;
33182 char * kwnames[] = {
33183 (char *) "self",(char *) "handler", NULL
33184 };
33185
33186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33188 if (!SWIG_IsOK(res1)) {
33189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33190 }
33191 arg1 = reinterpret_cast< wxWindow * >(argp1);
33192 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33193 if (!SWIG_IsOK(res2)) {
33194 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33195 }
33196 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33197 {
33198 PyThreadState* __tstate = wxPyBeginAllowThreads();
33199 (arg1)->SetEventHandler(arg2);
33200 wxPyEndAllowThreads(__tstate);
33201 if (PyErr_Occurred()) SWIG_fail;
33202 }
33203 resultobj = SWIG_Py_Void();
33204 return resultobj;
33205 fail:
33206 return NULL;
33207 }
33208
33209
33210 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33211 PyObject *resultobj = 0;
33212 wxWindow *arg1 = (wxWindow *) 0 ;
33213 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33214 void *argp1 = 0 ;
33215 int res1 = 0 ;
33216 void *argp2 = 0 ;
33217 int res2 = 0 ;
33218 PyObject * obj0 = 0 ;
33219 PyObject * obj1 = 0 ;
33220 char * kwnames[] = {
33221 (char *) "self",(char *) "handler", NULL
33222 };
33223
33224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33226 if (!SWIG_IsOK(res1)) {
33227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33228 }
33229 arg1 = reinterpret_cast< wxWindow * >(argp1);
33230 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33231 if (!SWIG_IsOK(res2)) {
33232 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33233 }
33234 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33235 {
33236 PyThreadState* __tstate = wxPyBeginAllowThreads();
33237 (arg1)->PushEventHandler(arg2);
33238 wxPyEndAllowThreads(__tstate);
33239 if (PyErr_Occurred()) SWIG_fail;
33240 }
33241 resultobj = SWIG_Py_Void();
33242 return resultobj;
33243 fail:
33244 return NULL;
33245 }
33246
33247
33248 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33249 PyObject *resultobj = 0;
33250 wxWindow *arg1 = (wxWindow *) 0 ;
33251 bool arg2 = (bool) false ;
33252 wxEvtHandler *result = 0 ;
33253 void *argp1 = 0 ;
33254 int res1 = 0 ;
33255 bool val2 ;
33256 int ecode2 = 0 ;
33257 PyObject * obj0 = 0 ;
33258 PyObject * obj1 = 0 ;
33259 char * kwnames[] = {
33260 (char *) "self",(char *) "deleteHandler", NULL
33261 };
33262
33263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33265 if (!SWIG_IsOK(res1)) {
33266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33267 }
33268 arg1 = reinterpret_cast< wxWindow * >(argp1);
33269 if (obj1) {
33270 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33271 if (!SWIG_IsOK(ecode2)) {
33272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33273 }
33274 arg2 = static_cast< bool >(val2);
33275 }
33276 {
33277 PyThreadState* __tstate = wxPyBeginAllowThreads();
33278 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33279 wxPyEndAllowThreads(__tstate);
33280 if (PyErr_Occurred()) SWIG_fail;
33281 }
33282 {
33283 resultobj = wxPyMake_wxObject(result, 0);
33284 }
33285 return resultobj;
33286 fail:
33287 return NULL;
33288 }
33289
33290
33291 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33292 PyObject *resultobj = 0;
33293 wxWindow *arg1 = (wxWindow *) 0 ;
33294 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33295 bool result;
33296 void *argp1 = 0 ;
33297 int res1 = 0 ;
33298 void *argp2 = 0 ;
33299 int res2 = 0 ;
33300 PyObject * obj0 = 0 ;
33301 PyObject * obj1 = 0 ;
33302 char * kwnames[] = {
33303 (char *) "self",(char *) "handler", NULL
33304 };
33305
33306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33308 if (!SWIG_IsOK(res1)) {
33309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33310 }
33311 arg1 = reinterpret_cast< wxWindow * >(argp1);
33312 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33313 if (!SWIG_IsOK(res2)) {
33314 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33315 }
33316 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33317 {
33318 PyThreadState* __tstate = wxPyBeginAllowThreads();
33319 result = (bool)(arg1)->RemoveEventHandler(arg2);
33320 wxPyEndAllowThreads(__tstate);
33321 if (PyErr_Occurred()) SWIG_fail;
33322 }
33323 {
33324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33325 }
33326 return resultobj;
33327 fail:
33328 return NULL;
33329 }
33330
33331
33332 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33333 PyObject *resultobj = 0;
33334 wxWindow *arg1 = (wxWindow *) 0 ;
33335 wxValidator *arg2 = 0 ;
33336 void *argp1 = 0 ;
33337 int res1 = 0 ;
33338 void *argp2 = 0 ;
33339 int res2 = 0 ;
33340 PyObject * obj0 = 0 ;
33341 PyObject * obj1 = 0 ;
33342 char * kwnames[] = {
33343 (char *) "self",(char *) "validator", NULL
33344 };
33345
33346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33348 if (!SWIG_IsOK(res1)) {
33349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33350 }
33351 arg1 = reinterpret_cast< wxWindow * >(argp1);
33352 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33353 if (!SWIG_IsOK(res2)) {
33354 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33355 }
33356 if (!argp2) {
33357 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33358 }
33359 arg2 = reinterpret_cast< wxValidator * >(argp2);
33360 {
33361 PyThreadState* __tstate = wxPyBeginAllowThreads();
33362 (arg1)->SetValidator((wxValidator const &)*arg2);
33363 wxPyEndAllowThreads(__tstate);
33364 if (PyErr_Occurred()) SWIG_fail;
33365 }
33366 resultobj = SWIG_Py_Void();
33367 return resultobj;
33368 fail:
33369 return NULL;
33370 }
33371
33372
33373 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33374 PyObject *resultobj = 0;
33375 wxWindow *arg1 = (wxWindow *) 0 ;
33376 wxValidator *result = 0 ;
33377 void *argp1 = 0 ;
33378 int res1 = 0 ;
33379 PyObject *swig_obj[1] ;
33380
33381 if (!args) SWIG_fail;
33382 swig_obj[0] = args;
33383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33384 if (!SWIG_IsOK(res1)) {
33385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33386 }
33387 arg1 = reinterpret_cast< wxWindow * >(argp1);
33388 {
33389 PyThreadState* __tstate = wxPyBeginAllowThreads();
33390 result = (wxValidator *)(arg1)->GetValidator();
33391 wxPyEndAllowThreads(__tstate);
33392 if (PyErr_Occurred()) SWIG_fail;
33393 }
33394 {
33395 resultobj = wxPyMake_wxObject(result, (bool)0);
33396 }
33397 return resultobj;
33398 fail:
33399 return NULL;
33400 }
33401
33402
33403 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33404 PyObject *resultobj = 0;
33405 wxWindow *arg1 = (wxWindow *) 0 ;
33406 bool result;
33407 void *argp1 = 0 ;
33408 int res1 = 0 ;
33409 PyObject *swig_obj[1] ;
33410
33411 if (!args) SWIG_fail;
33412 swig_obj[0] = args;
33413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33414 if (!SWIG_IsOK(res1)) {
33415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33416 }
33417 arg1 = reinterpret_cast< wxWindow * >(argp1);
33418 {
33419 PyThreadState* __tstate = wxPyBeginAllowThreads();
33420 result = (bool)(arg1)->Validate();
33421 wxPyEndAllowThreads(__tstate);
33422 if (PyErr_Occurred()) SWIG_fail;
33423 }
33424 {
33425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33426 }
33427 return resultobj;
33428 fail:
33429 return NULL;
33430 }
33431
33432
33433 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33434 PyObject *resultobj = 0;
33435 wxWindow *arg1 = (wxWindow *) 0 ;
33436 bool result;
33437 void *argp1 = 0 ;
33438 int res1 = 0 ;
33439 PyObject *swig_obj[1] ;
33440
33441 if (!args) SWIG_fail;
33442 swig_obj[0] = args;
33443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33444 if (!SWIG_IsOK(res1)) {
33445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33446 }
33447 arg1 = reinterpret_cast< wxWindow * >(argp1);
33448 {
33449 PyThreadState* __tstate = wxPyBeginAllowThreads();
33450 result = (bool)(arg1)->TransferDataToWindow();
33451 wxPyEndAllowThreads(__tstate);
33452 if (PyErr_Occurred()) SWIG_fail;
33453 }
33454 {
33455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33456 }
33457 return resultobj;
33458 fail:
33459 return NULL;
33460 }
33461
33462
33463 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33464 PyObject *resultobj = 0;
33465 wxWindow *arg1 = (wxWindow *) 0 ;
33466 bool result;
33467 void *argp1 = 0 ;
33468 int res1 = 0 ;
33469 PyObject *swig_obj[1] ;
33470
33471 if (!args) SWIG_fail;
33472 swig_obj[0] = args;
33473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33474 if (!SWIG_IsOK(res1)) {
33475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33476 }
33477 arg1 = reinterpret_cast< wxWindow * >(argp1);
33478 {
33479 PyThreadState* __tstate = wxPyBeginAllowThreads();
33480 result = (bool)(arg1)->TransferDataFromWindow();
33481 wxPyEndAllowThreads(__tstate);
33482 if (PyErr_Occurred()) SWIG_fail;
33483 }
33484 {
33485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33486 }
33487 return resultobj;
33488 fail:
33489 return NULL;
33490 }
33491
33492
33493 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33494 PyObject *resultobj = 0;
33495 wxWindow *arg1 = (wxWindow *) 0 ;
33496 void *argp1 = 0 ;
33497 int res1 = 0 ;
33498 PyObject *swig_obj[1] ;
33499
33500 if (!args) SWIG_fail;
33501 swig_obj[0] = args;
33502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33503 if (!SWIG_IsOK(res1)) {
33504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33505 }
33506 arg1 = reinterpret_cast< wxWindow * >(argp1);
33507 {
33508 PyThreadState* __tstate = wxPyBeginAllowThreads();
33509 (arg1)->InitDialog();
33510 wxPyEndAllowThreads(__tstate);
33511 if (PyErr_Occurred()) SWIG_fail;
33512 }
33513 resultobj = SWIG_Py_Void();
33514 return resultobj;
33515 fail:
33516 return NULL;
33517 }
33518
33519
33520 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33521 PyObject *resultobj = 0;
33522 wxWindow *arg1 = (wxWindow *) 0 ;
33523 wxAcceleratorTable *arg2 = 0 ;
33524 void *argp1 = 0 ;
33525 int res1 = 0 ;
33526 void *argp2 = 0 ;
33527 int res2 = 0 ;
33528 PyObject * obj0 = 0 ;
33529 PyObject * obj1 = 0 ;
33530 char * kwnames[] = {
33531 (char *) "self",(char *) "accel", NULL
33532 };
33533
33534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33536 if (!SWIG_IsOK(res1)) {
33537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33538 }
33539 arg1 = reinterpret_cast< wxWindow * >(argp1);
33540 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33541 if (!SWIG_IsOK(res2)) {
33542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33543 }
33544 if (!argp2) {
33545 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33546 }
33547 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33548 {
33549 PyThreadState* __tstate = wxPyBeginAllowThreads();
33550 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33551 wxPyEndAllowThreads(__tstate);
33552 if (PyErr_Occurred()) SWIG_fail;
33553 }
33554 resultobj = SWIG_Py_Void();
33555 return resultobj;
33556 fail:
33557 return NULL;
33558 }
33559
33560
33561 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33562 PyObject *resultobj = 0;
33563 wxWindow *arg1 = (wxWindow *) 0 ;
33564 wxAcceleratorTable *result = 0 ;
33565 void *argp1 = 0 ;
33566 int res1 = 0 ;
33567 PyObject *swig_obj[1] ;
33568
33569 if (!args) SWIG_fail;
33570 swig_obj[0] = args;
33571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33572 if (!SWIG_IsOK(res1)) {
33573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33574 }
33575 arg1 = reinterpret_cast< wxWindow * >(argp1);
33576 {
33577 PyThreadState* __tstate = wxPyBeginAllowThreads();
33578 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33579 wxPyEndAllowThreads(__tstate);
33580 if (PyErr_Occurred()) SWIG_fail;
33581 }
33582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33583 return resultobj;
33584 fail:
33585 return NULL;
33586 }
33587
33588
33589 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33590 PyObject *resultobj = 0;
33591 wxWindow *arg1 = (wxWindow *) 0 ;
33592 int arg2 ;
33593 int arg3 ;
33594 int arg4 ;
33595 bool result;
33596 void *argp1 = 0 ;
33597 int res1 = 0 ;
33598 int val2 ;
33599 int ecode2 = 0 ;
33600 int val3 ;
33601 int ecode3 = 0 ;
33602 int val4 ;
33603 int ecode4 = 0 ;
33604 PyObject * obj0 = 0 ;
33605 PyObject * obj1 = 0 ;
33606 PyObject * obj2 = 0 ;
33607 PyObject * obj3 = 0 ;
33608 char * kwnames[] = {
33609 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33610 };
33611
33612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33614 if (!SWIG_IsOK(res1)) {
33615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33616 }
33617 arg1 = reinterpret_cast< wxWindow * >(argp1);
33618 ecode2 = SWIG_AsVal_int(obj1, &val2);
33619 if (!SWIG_IsOK(ecode2)) {
33620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33621 }
33622 arg2 = static_cast< int >(val2);
33623 ecode3 = SWIG_AsVal_int(obj2, &val3);
33624 if (!SWIG_IsOK(ecode3)) {
33625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33626 }
33627 arg3 = static_cast< int >(val3);
33628 ecode4 = SWIG_AsVal_int(obj3, &val4);
33629 if (!SWIG_IsOK(ecode4)) {
33630 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33631 }
33632 arg4 = static_cast< int >(val4);
33633 {
33634 PyThreadState* __tstate = wxPyBeginAllowThreads();
33635 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33636 wxPyEndAllowThreads(__tstate);
33637 if (PyErr_Occurred()) SWIG_fail;
33638 }
33639 {
33640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33641 }
33642 return resultobj;
33643 fail:
33644 return NULL;
33645 }
33646
33647
33648 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33649 PyObject *resultobj = 0;
33650 wxWindow *arg1 = (wxWindow *) 0 ;
33651 int arg2 ;
33652 bool result;
33653 void *argp1 = 0 ;
33654 int res1 = 0 ;
33655 int val2 ;
33656 int ecode2 = 0 ;
33657 PyObject * obj0 = 0 ;
33658 PyObject * obj1 = 0 ;
33659 char * kwnames[] = {
33660 (char *) "self",(char *) "hotkeyId", NULL
33661 };
33662
33663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33665 if (!SWIG_IsOK(res1)) {
33666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33667 }
33668 arg1 = reinterpret_cast< wxWindow * >(argp1);
33669 ecode2 = SWIG_AsVal_int(obj1, &val2);
33670 if (!SWIG_IsOK(ecode2)) {
33671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33672 }
33673 arg2 = static_cast< int >(val2);
33674 {
33675 PyThreadState* __tstate = wxPyBeginAllowThreads();
33676 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33677 wxPyEndAllowThreads(__tstate);
33678 if (PyErr_Occurred()) SWIG_fail;
33679 }
33680 {
33681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33682 }
33683 return resultobj;
33684 fail:
33685 return NULL;
33686 }
33687
33688
33689 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33690 PyObject *resultobj = 0;
33691 wxWindow *arg1 = (wxWindow *) 0 ;
33692 wxPoint *arg2 = 0 ;
33693 wxPoint result;
33694 void *argp1 = 0 ;
33695 int res1 = 0 ;
33696 wxPoint temp2 ;
33697 PyObject * obj0 = 0 ;
33698 PyObject * obj1 = 0 ;
33699 char * kwnames[] = {
33700 (char *) "self",(char *) "pt", NULL
33701 };
33702
33703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33705 if (!SWIG_IsOK(res1)) {
33706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33707 }
33708 arg1 = reinterpret_cast< wxWindow * >(argp1);
33709 {
33710 arg2 = &temp2;
33711 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33712 }
33713 {
33714 PyThreadState* __tstate = wxPyBeginAllowThreads();
33715 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33716 wxPyEndAllowThreads(__tstate);
33717 if (PyErr_Occurred()) SWIG_fail;
33718 }
33719 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33720 return resultobj;
33721 fail:
33722 return NULL;
33723 }
33724
33725
33726 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33727 PyObject *resultobj = 0;
33728 wxWindow *arg1 = (wxWindow *) 0 ;
33729 wxSize *arg2 = 0 ;
33730 wxSize result;
33731 void *argp1 = 0 ;
33732 int res1 = 0 ;
33733 wxSize temp2 ;
33734 PyObject * obj0 = 0 ;
33735 PyObject * obj1 = 0 ;
33736 char * kwnames[] = {
33737 (char *) "self",(char *) "sz", NULL
33738 };
33739
33740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33742 if (!SWIG_IsOK(res1)) {
33743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33744 }
33745 arg1 = reinterpret_cast< wxWindow * >(argp1);
33746 {
33747 arg2 = &temp2;
33748 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33749 }
33750 {
33751 PyThreadState* __tstate = wxPyBeginAllowThreads();
33752 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33753 wxPyEndAllowThreads(__tstate);
33754 if (PyErr_Occurred()) SWIG_fail;
33755 }
33756 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33757 return resultobj;
33758 fail:
33759 return NULL;
33760 }
33761
33762
33763 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33764 PyObject *resultobj = 0;
33765 wxWindow *arg1 = (wxWindow *) 0 ;
33766 wxPoint *arg2 = 0 ;
33767 wxPoint result;
33768 void *argp1 = 0 ;
33769 int res1 = 0 ;
33770 wxPoint temp2 ;
33771 PyObject * obj0 = 0 ;
33772 PyObject * obj1 = 0 ;
33773 char * kwnames[] = {
33774 (char *) "self",(char *) "pt", NULL
33775 };
33776
33777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33779 if (!SWIG_IsOK(res1)) {
33780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33781 }
33782 arg1 = reinterpret_cast< wxWindow * >(argp1);
33783 {
33784 arg2 = &temp2;
33785 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33786 }
33787 {
33788 PyThreadState* __tstate = wxPyBeginAllowThreads();
33789 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33790 wxPyEndAllowThreads(__tstate);
33791 if (PyErr_Occurred()) SWIG_fail;
33792 }
33793 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33794 return resultobj;
33795 fail:
33796 return NULL;
33797 }
33798
33799
33800 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33801 PyObject *resultobj = 0;
33802 wxWindow *arg1 = (wxWindow *) 0 ;
33803 wxSize *arg2 = 0 ;
33804 wxSize result;
33805 void *argp1 = 0 ;
33806 int res1 = 0 ;
33807 wxSize temp2 ;
33808 PyObject * obj0 = 0 ;
33809 PyObject * obj1 = 0 ;
33810 char * kwnames[] = {
33811 (char *) "self",(char *) "sz", NULL
33812 };
33813
33814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
33815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33816 if (!SWIG_IsOK(res1)) {
33817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
33818 }
33819 arg1 = reinterpret_cast< wxWindow * >(argp1);
33820 {
33821 arg2 = &temp2;
33822 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33823 }
33824 {
33825 PyThreadState* __tstate = wxPyBeginAllowThreads();
33826 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33827 wxPyEndAllowThreads(__tstate);
33828 if (PyErr_Occurred()) SWIG_fail;
33829 }
33830 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33831 return resultobj;
33832 fail:
33833 return NULL;
33834 }
33835
33836
33837 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33838 PyObject *resultobj = 0;
33839 wxWindow *arg1 = (wxWindow *) 0 ;
33840 wxPoint *arg2 = 0 ;
33841 wxPoint result;
33842 void *argp1 = 0 ;
33843 int res1 = 0 ;
33844 wxPoint temp2 ;
33845 PyObject * obj0 = 0 ;
33846 PyObject * obj1 = 0 ;
33847 char * kwnames[] = {
33848 (char *) "self",(char *) "pt", NULL
33849 };
33850
33851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33853 if (!SWIG_IsOK(res1)) {
33854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33855 }
33856 arg1 = reinterpret_cast< wxWindow * >(argp1);
33857 {
33858 arg2 = &temp2;
33859 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33860 }
33861 {
33862 PyThreadState* __tstate = wxPyBeginAllowThreads();
33863 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
33864 wxPyEndAllowThreads(__tstate);
33865 if (PyErr_Occurred()) SWIG_fail;
33866 }
33867 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33868 return resultobj;
33869 fail:
33870 return NULL;
33871 }
33872
33873
33874 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33875 PyObject *resultobj = 0;
33876 wxWindow *arg1 = (wxWindow *) 0 ;
33877 wxSize *arg2 = 0 ;
33878 wxSize result;
33879 void *argp1 = 0 ;
33880 int res1 = 0 ;
33881 wxSize temp2 ;
33882 PyObject * obj0 = 0 ;
33883 PyObject * obj1 = 0 ;
33884 char * kwnames[] = {
33885 (char *) "self",(char *) "sz", NULL
33886 };
33887
33888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33890 if (!SWIG_IsOK(res1)) {
33891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33892 }
33893 arg1 = reinterpret_cast< wxWindow * >(argp1);
33894 {
33895 arg2 = &temp2;
33896 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33897 }
33898 {
33899 PyThreadState* __tstate = wxPyBeginAllowThreads();
33900 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
33901 wxPyEndAllowThreads(__tstate);
33902 if (PyErr_Occurred()) SWIG_fail;
33903 }
33904 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33905 return resultobj;
33906 fail:
33907 return NULL;
33908 }
33909
33910
33911 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33912 PyObject *resultobj = 0;
33913 wxWindow *arg1 = (wxWindow *) 0 ;
33914 int arg2 ;
33915 int arg3 ;
33916 void *argp1 = 0 ;
33917 int res1 = 0 ;
33918 int val2 ;
33919 int ecode2 = 0 ;
33920 int val3 ;
33921 int ecode3 = 0 ;
33922 PyObject * obj0 = 0 ;
33923 PyObject * obj1 = 0 ;
33924 PyObject * obj2 = 0 ;
33925 char * kwnames[] = {
33926 (char *) "self",(char *) "x",(char *) "y", NULL
33927 };
33928
33929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33931 if (!SWIG_IsOK(res1)) {
33932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
33933 }
33934 arg1 = reinterpret_cast< wxWindow * >(argp1);
33935 ecode2 = SWIG_AsVal_int(obj1, &val2);
33936 if (!SWIG_IsOK(ecode2)) {
33937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
33938 }
33939 arg2 = static_cast< int >(val2);
33940 ecode3 = SWIG_AsVal_int(obj2, &val3);
33941 if (!SWIG_IsOK(ecode3)) {
33942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
33943 }
33944 arg3 = static_cast< int >(val3);
33945 {
33946 PyThreadState* __tstate = wxPyBeginAllowThreads();
33947 (arg1)->WarpPointer(arg2,arg3);
33948 wxPyEndAllowThreads(__tstate);
33949 if (PyErr_Occurred()) SWIG_fail;
33950 }
33951 resultobj = SWIG_Py_Void();
33952 return resultobj;
33953 fail:
33954 return NULL;
33955 }
33956
33957
33958 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33959 PyObject *resultobj = 0;
33960 wxWindow *arg1 = (wxWindow *) 0 ;
33961 void *argp1 = 0 ;
33962 int res1 = 0 ;
33963 PyObject *swig_obj[1] ;
33964
33965 if (!args) SWIG_fail;
33966 swig_obj[0] = args;
33967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33968 if (!SWIG_IsOK(res1)) {
33969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
33970 }
33971 arg1 = reinterpret_cast< wxWindow * >(argp1);
33972 {
33973 PyThreadState* __tstate = wxPyBeginAllowThreads();
33974 (arg1)->CaptureMouse();
33975 wxPyEndAllowThreads(__tstate);
33976 if (PyErr_Occurred()) SWIG_fail;
33977 }
33978 resultobj = SWIG_Py_Void();
33979 return resultobj;
33980 fail:
33981 return NULL;
33982 }
33983
33984
33985 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33986 PyObject *resultobj = 0;
33987 wxWindow *arg1 = (wxWindow *) 0 ;
33988 void *argp1 = 0 ;
33989 int res1 = 0 ;
33990 PyObject *swig_obj[1] ;
33991
33992 if (!args) SWIG_fail;
33993 swig_obj[0] = args;
33994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33995 if (!SWIG_IsOK(res1)) {
33996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
33997 }
33998 arg1 = reinterpret_cast< wxWindow * >(argp1);
33999 {
34000 PyThreadState* __tstate = wxPyBeginAllowThreads();
34001 (arg1)->ReleaseMouse();
34002 wxPyEndAllowThreads(__tstate);
34003 if (PyErr_Occurred()) SWIG_fail;
34004 }
34005 resultobj = SWIG_Py_Void();
34006 return resultobj;
34007 fail:
34008 return NULL;
34009 }
34010
34011
34012 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34013 PyObject *resultobj = 0;
34014 wxWindow *result = 0 ;
34015
34016 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34017 {
34018 if (!wxPyCheckForApp()) SWIG_fail;
34019 PyThreadState* __tstate = wxPyBeginAllowThreads();
34020 result = (wxWindow *)wxWindow::GetCapture();
34021 wxPyEndAllowThreads(__tstate);
34022 if (PyErr_Occurred()) SWIG_fail;
34023 }
34024 {
34025 resultobj = wxPyMake_wxObject(result, 0);
34026 }
34027 return resultobj;
34028 fail:
34029 return NULL;
34030 }
34031
34032
34033 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34034 PyObject *resultobj = 0;
34035 wxWindow *arg1 = (wxWindow *) 0 ;
34036 bool result;
34037 void *argp1 = 0 ;
34038 int res1 = 0 ;
34039 PyObject *swig_obj[1] ;
34040
34041 if (!args) SWIG_fail;
34042 swig_obj[0] = args;
34043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34044 if (!SWIG_IsOK(res1)) {
34045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34046 }
34047 arg1 = reinterpret_cast< wxWindow * >(argp1);
34048 {
34049 PyThreadState* __tstate = wxPyBeginAllowThreads();
34050 result = (bool)((wxWindow const *)arg1)->HasCapture();
34051 wxPyEndAllowThreads(__tstate);
34052 if (PyErr_Occurred()) SWIG_fail;
34053 }
34054 {
34055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34056 }
34057 return resultobj;
34058 fail:
34059 return NULL;
34060 }
34061
34062
34063 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34064 PyObject *resultobj = 0;
34065 wxWindow *arg1 = (wxWindow *) 0 ;
34066 bool arg2 = (bool) true ;
34067 wxRect *arg3 = (wxRect *) NULL ;
34068 void *argp1 = 0 ;
34069 int res1 = 0 ;
34070 bool val2 ;
34071 int ecode2 = 0 ;
34072 void *argp3 = 0 ;
34073 int res3 = 0 ;
34074 PyObject * obj0 = 0 ;
34075 PyObject * obj1 = 0 ;
34076 PyObject * obj2 = 0 ;
34077 char * kwnames[] = {
34078 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34079 };
34080
34081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34083 if (!SWIG_IsOK(res1)) {
34084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34085 }
34086 arg1 = reinterpret_cast< wxWindow * >(argp1);
34087 if (obj1) {
34088 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34089 if (!SWIG_IsOK(ecode2)) {
34090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34091 }
34092 arg2 = static_cast< bool >(val2);
34093 }
34094 if (obj2) {
34095 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34096 if (!SWIG_IsOK(res3)) {
34097 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34098 }
34099 arg3 = reinterpret_cast< wxRect * >(argp3);
34100 }
34101 {
34102 PyThreadState* __tstate = wxPyBeginAllowThreads();
34103 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34104 wxPyEndAllowThreads(__tstate);
34105 if (PyErr_Occurred()) SWIG_fail;
34106 }
34107 resultobj = SWIG_Py_Void();
34108 return resultobj;
34109 fail:
34110 return NULL;
34111 }
34112
34113
34114 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34115 PyObject *resultobj = 0;
34116 wxWindow *arg1 = (wxWindow *) 0 ;
34117 wxRect *arg2 = 0 ;
34118 bool arg3 = (bool) true ;
34119 void *argp1 = 0 ;
34120 int res1 = 0 ;
34121 wxRect temp2 ;
34122 bool val3 ;
34123 int ecode3 = 0 ;
34124 PyObject * obj0 = 0 ;
34125 PyObject * obj1 = 0 ;
34126 PyObject * obj2 = 0 ;
34127 char * kwnames[] = {
34128 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34129 };
34130
34131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34133 if (!SWIG_IsOK(res1)) {
34134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34135 }
34136 arg1 = reinterpret_cast< wxWindow * >(argp1);
34137 {
34138 arg2 = &temp2;
34139 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34140 }
34141 if (obj2) {
34142 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34143 if (!SWIG_IsOK(ecode3)) {
34144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34145 }
34146 arg3 = static_cast< bool >(val3);
34147 }
34148 {
34149 PyThreadState* __tstate = wxPyBeginAllowThreads();
34150 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34151 wxPyEndAllowThreads(__tstate);
34152 if (PyErr_Occurred()) SWIG_fail;
34153 }
34154 resultobj = SWIG_Py_Void();
34155 return resultobj;
34156 fail:
34157 return NULL;
34158 }
34159
34160
34161 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34162 PyObject *resultobj = 0;
34163 wxWindow *arg1 = (wxWindow *) 0 ;
34164 void *argp1 = 0 ;
34165 int res1 = 0 ;
34166 PyObject *swig_obj[1] ;
34167
34168 if (!args) SWIG_fail;
34169 swig_obj[0] = args;
34170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34171 if (!SWIG_IsOK(res1)) {
34172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34173 }
34174 arg1 = reinterpret_cast< wxWindow * >(argp1);
34175 {
34176 PyThreadState* __tstate = wxPyBeginAllowThreads();
34177 (arg1)->Update();
34178 wxPyEndAllowThreads(__tstate);
34179 if (PyErr_Occurred()) SWIG_fail;
34180 }
34181 resultobj = SWIG_Py_Void();
34182 return resultobj;
34183 fail:
34184 return NULL;
34185 }
34186
34187
34188 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34189 PyObject *resultobj = 0;
34190 wxWindow *arg1 = (wxWindow *) 0 ;
34191 void *argp1 = 0 ;
34192 int res1 = 0 ;
34193 PyObject *swig_obj[1] ;
34194
34195 if (!args) SWIG_fail;
34196 swig_obj[0] = args;
34197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34198 if (!SWIG_IsOK(res1)) {
34199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34200 }
34201 arg1 = reinterpret_cast< wxWindow * >(argp1);
34202 {
34203 PyThreadState* __tstate = wxPyBeginAllowThreads();
34204 (arg1)->ClearBackground();
34205 wxPyEndAllowThreads(__tstate);
34206 if (PyErr_Occurred()) SWIG_fail;
34207 }
34208 resultobj = SWIG_Py_Void();
34209 return resultobj;
34210 fail:
34211 return NULL;
34212 }
34213
34214
34215 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34216 PyObject *resultobj = 0;
34217 wxWindow *arg1 = (wxWindow *) 0 ;
34218 void *argp1 = 0 ;
34219 int res1 = 0 ;
34220 PyObject *swig_obj[1] ;
34221
34222 if (!args) SWIG_fail;
34223 swig_obj[0] = args;
34224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34225 if (!SWIG_IsOK(res1)) {
34226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34227 }
34228 arg1 = reinterpret_cast< wxWindow * >(argp1);
34229 {
34230 PyThreadState* __tstate = wxPyBeginAllowThreads();
34231 (arg1)->Freeze();
34232 wxPyEndAllowThreads(__tstate);
34233 if (PyErr_Occurred()) SWIG_fail;
34234 }
34235 resultobj = SWIG_Py_Void();
34236 return resultobj;
34237 fail:
34238 return NULL;
34239 }
34240
34241
34242 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34243 PyObject *resultobj = 0;
34244 wxWindow *arg1 = (wxWindow *) 0 ;
34245 void *argp1 = 0 ;
34246 int res1 = 0 ;
34247 PyObject *swig_obj[1] ;
34248
34249 if (!args) SWIG_fail;
34250 swig_obj[0] = args;
34251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34252 if (!SWIG_IsOK(res1)) {
34253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34254 }
34255 arg1 = reinterpret_cast< wxWindow * >(argp1);
34256 {
34257 PyThreadState* __tstate = wxPyBeginAllowThreads();
34258 (arg1)->Thaw();
34259 wxPyEndAllowThreads(__tstate);
34260 if (PyErr_Occurred()) SWIG_fail;
34261 }
34262 resultobj = SWIG_Py_Void();
34263 return resultobj;
34264 fail:
34265 return NULL;
34266 }
34267
34268
34269 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34270 PyObject *resultobj = 0;
34271 wxWindow *arg1 = (wxWindow *) 0 ;
34272 wxDC *arg2 = 0 ;
34273 void *argp1 = 0 ;
34274 int res1 = 0 ;
34275 void *argp2 = 0 ;
34276 int res2 = 0 ;
34277 PyObject * obj0 = 0 ;
34278 PyObject * obj1 = 0 ;
34279 char * kwnames[] = {
34280 (char *) "self",(char *) "dc", NULL
34281 };
34282
34283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34285 if (!SWIG_IsOK(res1)) {
34286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34287 }
34288 arg1 = reinterpret_cast< wxWindow * >(argp1);
34289 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34290 if (!SWIG_IsOK(res2)) {
34291 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34292 }
34293 if (!argp2) {
34294 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34295 }
34296 arg2 = reinterpret_cast< wxDC * >(argp2);
34297 {
34298 PyThreadState* __tstate = wxPyBeginAllowThreads();
34299 (arg1)->PrepareDC(*arg2);
34300 wxPyEndAllowThreads(__tstate);
34301 if (PyErr_Occurred()) SWIG_fail;
34302 }
34303 resultobj = SWIG_Py_Void();
34304 return resultobj;
34305 fail:
34306 return NULL;
34307 }
34308
34309
34310 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34311 PyObject *resultobj = 0;
34312 wxWindow *arg1 = (wxWindow *) 0 ;
34313 wxRegion *result = 0 ;
34314 void *argp1 = 0 ;
34315 int res1 = 0 ;
34316 PyObject *swig_obj[1] ;
34317
34318 if (!args) SWIG_fail;
34319 swig_obj[0] = args;
34320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34321 if (!SWIG_IsOK(res1)) {
34322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34323 }
34324 arg1 = reinterpret_cast< wxWindow * >(argp1);
34325 {
34326 PyThreadState* __tstate = wxPyBeginAllowThreads();
34327 {
34328 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34329 result = (wxRegion *) &_result_ref;
34330 }
34331 wxPyEndAllowThreads(__tstate);
34332 if (PyErr_Occurred()) SWIG_fail;
34333 }
34334 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34335 return resultobj;
34336 fail:
34337 return NULL;
34338 }
34339
34340
34341 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34342 PyObject *resultobj = 0;
34343 wxWindow *arg1 = (wxWindow *) 0 ;
34344 wxRect result;
34345 void *argp1 = 0 ;
34346 int res1 = 0 ;
34347 PyObject *swig_obj[1] ;
34348
34349 if (!args) SWIG_fail;
34350 swig_obj[0] = args;
34351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34352 if (!SWIG_IsOK(res1)) {
34353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34354 }
34355 arg1 = reinterpret_cast< wxWindow * >(argp1);
34356 {
34357 PyThreadState* __tstate = wxPyBeginAllowThreads();
34358 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34359 wxPyEndAllowThreads(__tstate);
34360 if (PyErr_Occurred()) SWIG_fail;
34361 }
34362 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34363 return resultobj;
34364 fail:
34365 return NULL;
34366 }
34367
34368
34369 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34370 PyObject *resultobj = 0;
34371 wxWindow *arg1 = (wxWindow *) 0 ;
34372 int arg2 ;
34373 int arg3 ;
34374 int arg4 = (int) 1 ;
34375 int arg5 = (int) 1 ;
34376 bool result;
34377 void *argp1 = 0 ;
34378 int res1 = 0 ;
34379 int val2 ;
34380 int ecode2 = 0 ;
34381 int val3 ;
34382 int ecode3 = 0 ;
34383 int val4 ;
34384 int ecode4 = 0 ;
34385 int val5 ;
34386 int ecode5 = 0 ;
34387 PyObject * obj0 = 0 ;
34388 PyObject * obj1 = 0 ;
34389 PyObject * obj2 = 0 ;
34390 PyObject * obj3 = 0 ;
34391 PyObject * obj4 = 0 ;
34392 char * kwnames[] = {
34393 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34394 };
34395
34396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34398 if (!SWIG_IsOK(res1)) {
34399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34400 }
34401 arg1 = reinterpret_cast< wxWindow * >(argp1);
34402 ecode2 = SWIG_AsVal_int(obj1, &val2);
34403 if (!SWIG_IsOK(ecode2)) {
34404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34405 }
34406 arg2 = static_cast< int >(val2);
34407 ecode3 = SWIG_AsVal_int(obj2, &val3);
34408 if (!SWIG_IsOK(ecode3)) {
34409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34410 }
34411 arg3 = static_cast< int >(val3);
34412 if (obj3) {
34413 ecode4 = SWIG_AsVal_int(obj3, &val4);
34414 if (!SWIG_IsOK(ecode4)) {
34415 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34416 }
34417 arg4 = static_cast< int >(val4);
34418 }
34419 if (obj4) {
34420 ecode5 = SWIG_AsVal_int(obj4, &val5);
34421 if (!SWIG_IsOK(ecode5)) {
34422 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34423 }
34424 arg5 = static_cast< int >(val5);
34425 }
34426 {
34427 PyThreadState* __tstate = wxPyBeginAllowThreads();
34428 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34429 wxPyEndAllowThreads(__tstate);
34430 if (PyErr_Occurred()) SWIG_fail;
34431 }
34432 {
34433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34434 }
34435 return resultobj;
34436 fail:
34437 return NULL;
34438 }
34439
34440
34441 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34442 PyObject *resultobj = 0;
34443 wxWindow *arg1 = (wxWindow *) 0 ;
34444 wxPoint *arg2 = 0 ;
34445 bool result;
34446 void *argp1 = 0 ;
34447 int res1 = 0 ;
34448 wxPoint temp2 ;
34449 PyObject * obj0 = 0 ;
34450 PyObject * obj1 = 0 ;
34451 char * kwnames[] = {
34452 (char *) "self",(char *) "pt", NULL
34453 };
34454
34455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34457 if (!SWIG_IsOK(res1)) {
34458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34459 }
34460 arg1 = reinterpret_cast< wxWindow * >(argp1);
34461 {
34462 arg2 = &temp2;
34463 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34464 }
34465 {
34466 PyThreadState* __tstate = wxPyBeginAllowThreads();
34467 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34468 wxPyEndAllowThreads(__tstate);
34469 if (PyErr_Occurred()) SWIG_fail;
34470 }
34471 {
34472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34473 }
34474 return resultobj;
34475 fail:
34476 return NULL;
34477 }
34478
34479
34480 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34481 PyObject *resultobj = 0;
34482 wxWindow *arg1 = (wxWindow *) 0 ;
34483 wxRect *arg2 = 0 ;
34484 bool result;
34485 void *argp1 = 0 ;
34486 int res1 = 0 ;
34487 wxRect temp2 ;
34488 PyObject * obj0 = 0 ;
34489 PyObject * obj1 = 0 ;
34490 char * kwnames[] = {
34491 (char *) "self",(char *) "rect", NULL
34492 };
34493
34494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34496 if (!SWIG_IsOK(res1)) {
34497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34498 }
34499 arg1 = reinterpret_cast< wxWindow * >(argp1);
34500 {
34501 arg2 = &temp2;
34502 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34503 }
34504 {
34505 PyThreadState* __tstate = wxPyBeginAllowThreads();
34506 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34507 wxPyEndAllowThreads(__tstate);
34508 if (PyErr_Occurred()) SWIG_fail;
34509 }
34510 {
34511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34512 }
34513 return resultobj;
34514 fail:
34515 return NULL;
34516 }
34517
34518
34519 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34520 PyObject *resultobj = 0;
34521 wxWindow *arg1 = (wxWindow *) 0 ;
34522 SwigValueWrapper<wxVisualAttributes > result;
34523 void *argp1 = 0 ;
34524 int res1 = 0 ;
34525 PyObject *swig_obj[1] ;
34526
34527 if (!args) SWIG_fail;
34528 swig_obj[0] = args;
34529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34530 if (!SWIG_IsOK(res1)) {
34531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34532 }
34533 arg1 = reinterpret_cast< wxWindow * >(argp1);
34534 {
34535 PyThreadState* __tstate = wxPyBeginAllowThreads();
34536 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34537 wxPyEndAllowThreads(__tstate);
34538 if (PyErr_Occurred()) SWIG_fail;
34539 }
34540 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34541 return resultobj;
34542 fail:
34543 return NULL;
34544 }
34545
34546
34547 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34548 PyObject *resultobj = 0;
34549 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34550 SwigValueWrapper<wxVisualAttributes > result;
34551 int val1 ;
34552 int ecode1 = 0 ;
34553 PyObject * obj0 = 0 ;
34554 char * kwnames[] = {
34555 (char *) "variant", NULL
34556 };
34557
34558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34559 if (obj0) {
34560 ecode1 = SWIG_AsVal_int(obj0, &val1);
34561 if (!SWIG_IsOK(ecode1)) {
34562 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34563 }
34564 arg1 = static_cast< wxWindowVariant >(val1);
34565 }
34566 {
34567 if (!wxPyCheckForApp()) SWIG_fail;
34568 PyThreadState* __tstate = wxPyBeginAllowThreads();
34569 result = wxWindow::GetClassDefaultAttributes(arg1);
34570 wxPyEndAllowThreads(__tstate);
34571 if (PyErr_Occurred()) SWIG_fail;
34572 }
34573 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34574 return resultobj;
34575 fail:
34576 return NULL;
34577 }
34578
34579
34580 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34581 PyObject *resultobj = 0;
34582 wxWindow *arg1 = (wxWindow *) 0 ;
34583 wxColour *arg2 = 0 ;
34584 bool result;
34585 void *argp1 = 0 ;
34586 int res1 = 0 ;
34587 wxColour temp2 ;
34588 PyObject * obj0 = 0 ;
34589 PyObject * obj1 = 0 ;
34590 char * kwnames[] = {
34591 (char *) "self",(char *) "colour", NULL
34592 };
34593
34594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34596 if (!SWIG_IsOK(res1)) {
34597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34598 }
34599 arg1 = reinterpret_cast< wxWindow * >(argp1);
34600 {
34601 arg2 = &temp2;
34602 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34603 }
34604 {
34605 PyThreadState* __tstate = wxPyBeginAllowThreads();
34606 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34607 wxPyEndAllowThreads(__tstate);
34608 if (PyErr_Occurred()) SWIG_fail;
34609 }
34610 {
34611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34612 }
34613 return resultobj;
34614 fail:
34615 return NULL;
34616 }
34617
34618
34619 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34620 PyObject *resultobj = 0;
34621 wxWindow *arg1 = (wxWindow *) 0 ;
34622 wxColour *arg2 = 0 ;
34623 void *argp1 = 0 ;
34624 int res1 = 0 ;
34625 wxColour temp2 ;
34626 PyObject * obj0 = 0 ;
34627 PyObject * obj1 = 0 ;
34628 char * kwnames[] = {
34629 (char *) "self",(char *) "colour", NULL
34630 };
34631
34632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34634 if (!SWIG_IsOK(res1)) {
34635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34636 }
34637 arg1 = reinterpret_cast< wxWindow * >(argp1);
34638 {
34639 arg2 = &temp2;
34640 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34641 }
34642 {
34643 PyThreadState* __tstate = wxPyBeginAllowThreads();
34644 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34645 wxPyEndAllowThreads(__tstate);
34646 if (PyErr_Occurred()) SWIG_fail;
34647 }
34648 resultobj = SWIG_Py_Void();
34649 return resultobj;
34650 fail:
34651 return NULL;
34652 }
34653
34654
34655 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34656 PyObject *resultobj = 0;
34657 wxWindow *arg1 = (wxWindow *) 0 ;
34658 wxColour *arg2 = 0 ;
34659 bool result;
34660 void *argp1 = 0 ;
34661 int res1 = 0 ;
34662 wxColour temp2 ;
34663 PyObject * obj0 = 0 ;
34664 PyObject * obj1 = 0 ;
34665 char * kwnames[] = {
34666 (char *) "self",(char *) "colour", NULL
34667 };
34668
34669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34671 if (!SWIG_IsOK(res1)) {
34672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34673 }
34674 arg1 = reinterpret_cast< wxWindow * >(argp1);
34675 {
34676 arg2 = &temp2;
34677 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34678 }
34679 {
34680 PyThreadState* __tstate = wxPyBeginAllowThreads();
34681 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34682 wxPyEndAllowThreads(__tstate);
34683 if (PyErr_Occurred()) SWIG_fail;
34684 }
34685 {
34686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34687 }
34688 return resultobj;
34689 fail:
34690 return NULL;
34691 }
34692
34693
34694 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34695 PyObject *resultobj = 0;
34696 wxWindow *arg1 = (wxWindow *) 0 ;
34697 wxColour *arg2 = 0 ;
34698 void *argp1 = 0 ;
34699 int res1 = 0 ;
34700 wxColour temp2 ;
34701 PyObject * obj0 = 0 ;
34702 PyObject * obj1 = 0 ;
34703 char * kwnames[] = {
34704 (char *) "self",(char *) "colour", NULL
34705 };
34706
34707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34709 if (!SWIG_IsOK(res1)) {
34710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34711 }
34712 arg1 = reinterpret_cast< wxWindow * >(argp1);
34713 {
34714 arg2 = &temp2;
34715 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34716 }
34717 {
34718 PyThreadState* __tstate = wxPyBeginAllowThreads();
34719 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34720 wxPyEndAllowThreads(__tstate);
34721 if (PyErr_Occurred()) SWIG_fail;
34722 }
34723 resultobj = SWIG_Py_Void();
34724 return resultobj;
34725 fail:
34726 return NULL;
34727 }
34728
34729
34730 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34731 PyObject *resultobj = 0;
34732 wxWindow *arg1 = (wxWindow *) 0 ;
34733 wxColour result;
34734 void *argp1 = 0 ;
34735 int res1 = 0 ;
34736 PyObject *swig_obj[1] ;
34737
34738 if (!args) SWIG_fail;
34739 swig_obj[0] = args;
34740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34741 if (!SWIG_IsOK(res1)) {
34742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34743 }
34744 arg1 = reinterpret_cast< wxWindow * >(argp1);
34745 {
34746 PyThreadState* __tstate = wxPyBeginAllowThreads();
34747 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34748 wxPyEndAllowThreads(__tstate);
34749 if (PyErr_Occurred()) SWIG_fail;
34750 }
34751 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34752 return resultobj;
34753 fail:
34754 return NULL;
34755 }
34756
34757
34758 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34759 PyObject *resultobj = 0;
34760 wxWindow *arg1 = (wxWindow *) 0 ;
34761 wxColour result;
34762 void *argp1 = 0 ;
34763 int res1 = 0 ;
34764 PyObject *swig_obj[1] ;
34765
34766 if (!args) SWIG_fail;
34767 swig_obj[0] = args;
34768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34769 if (!SWIG_IsOK(res1)) {
34770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34771 }
34772 arg1 = reinterpret_cast< wxWindow * >(argp1);
34773 {
34774 PyThreadState* __tstate = wxPyBeginAllowThreads();
34775 result = ((wxWindow const *)arg1)->GetForegroundColour();
34776 wxPyEndAllowThreads(__tstate);
34777 if (PyErr_Occurred()) SWIG_fail;
34778 }
34779 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34780 return resultobj;
34781 fail:
34782 return NULL;
34783 }
34784
34785
34786 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34787 PyObject *resultobj = 0;
34788 wxWindow *arg1 = (wxWindow *) 0 ;
34789 bool result;
34790 void *argp1 = 0 ;
34791 int res1 = 0 ;
34792 PyObject *swig_obj[1] ;
34793
34794 if (!args) SWIG_fail;
34795 swig_obj[0] = args;
34796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34797 if (!SWIG_IsOK(res1)) {
34798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34799 }
34800 arg1 = reinterpret_cast< wxWindow * >(argp1);
34801 {
34802 PyThreadState* __tstate = wxPyBeginAllowThreads();
34803 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34804 wxPyEndAllowThreads(__tstate);
34805 if (PyErr_Occurred()) SWIG_fail;
34806 }
34807 {
34808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34809 }
34810 return resultobj;
34811 fail:
34812 return NULL;
34813 }
34814
34815
34816 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34817 PyObject *resultobj = 0;
34818 wxWindow *arg1 = (wxWindow *) 0 ;
34819 bool result;
34820 void *argp1 = 0 ;
34821 int res1 = 0 ;
34822 PyObject *swig_obj[1] ;
34823
34824 if (!args) SWIG_fail;
34825 swig_obj[0] = args;
34826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34827 if (!SWIG_IsOK(res1)) {
34828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
34829 }
34830 arg1 = reinterpret_cast< wxWindow * >(argp1);
34831 {
34832 PyThreadState* __tstate = wxPyBeginAllowThreads();
34833 result = (bool)((wxWindow const *)arg1)->UseBgCol();
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_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34847 PyObject *resultobj = 0;
34848 wxWindow *arg1 = (wxWindow *) 0 ;
34849 wxBackgroundStyle arg2 ;
34850 bool result;
34851 void *argp1 = 0 ;
34852 int res1 = 0 ;
34853 int val2 ;
34854 int ecode2 = 0 ;
34855 PyObject * obj0 = 0 ;
34856 PyObject * obj1 = 0 ;
34857 char * kwnames[] = {
34858 (char *) "self",(char *) "style", NULL
34859 };
34860
34861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
34862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34863 if (!SWIG_IsOK(res1)) {
34864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
34865 }
34866 arg1 = reinterpret_cast< wxWindow * >(argp1);
34867 ecode2 = SWIG_AsVal_int(obj1, &val2);
34868 if (!SWIG_IsOK(ecode2)) {
34869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
34870 }
34871 arg2 = static_cast< wxBackgroundStyle >(val2);
34872 {
34873 PyThreadState* __tstate = wxPyBeginAllowThreads();
34874 result = (bool)(arg1)->SetBackgroundStyle(arg2);
34875 wxPyEndAllowThreads(__tstate);
34876 if (PyErr_Occurred()) SWIG_fail;
34877 }
34878 {
34879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34880 }
34881 return resultobj;
34882 fail:
34883 return NULL;
34884 }
34885
34886
34887 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34888 PyObject *resultobj = 0;
34889 wxWindow *arg1 = (wxWindow *) 0 ;
34890 wxBackgroundStyle result;
34891 void *argp1 = 0 ;
34892 int res1 = 0 ;
34893 PyObject *swig_obj[1] ;
34894
34895 if (!args) SWIG_fail;
34896 swig_obj[0] = args;
34897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34898 if (!SWIG_IsOK(res1)) {
34899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
34900 }
34901 arg1 = reinterpret_cast< wxWindow * >(argp1);
34902 {
34903 PyThreadState* __tstate = wxPyBeginAllowThreads();
34904 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
34905 wxPyEndAllowThreads(__tstate);
34906 if (PyErr_Occurred()) SWIG_fail;
34907 }
34908 resultobj = SWIG_From_int(static_cast< int >(result));
34909 return resultobj;
34910 fail:
34911 return NULL;
34912 }
34913
34914
34915 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34916 PyObject *resultobj = 0;
34917 wxWindow *arg1 = (wxWindow *) 0 ;
34918 bool result;
34919 void *argp1 = 0 ;
34920 int res1 = 0 ;
34921 PyObject *swig_obj[1] ;
34922
34923 if (!args) SWIG_fail;
34924 swig_obj[0] = args;
34925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34926 if (!SWIG_IsOK(res1)) {
34927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34928 }
34929 arg1 = reinterpret_cast< wxWindow * >(argp1);
34930 {
34931 PyThreadState* __tstate = wxPyBeginAllowThreads();
34932 result = (bool)(arg1)->HasTransparentBackground();
34933 wxPyEndAllowThreads(__tstate);
34934 if (PyErr_Occurred()) SWIG_fail;
34935 }
34936 {
34937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34938 }
34939 return resultobj;
34940 fail:
34941 return NULL;
34942 }
34943
34944
34945 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34946 PyObject *resultobj = 0;
34947 wxWindow *arg1 = (wxWindow *) 0 ;
34948 wxCursor *arg2 = 0 ;
34949 bool result;
34950 void *argp1 = 0 ;
34951 int res1 = 0 ;
34952 void *argp2 = 0 ;
34953 int res2 = 0 ;
34954 PyObject * obj0 = 0 ;
34955 PyObject * obj1 = 0 ;
34956 char * kwnames[] = {
34957 (char *) "self",(char *) "cursor", NULL
34958 };
34959
34960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
34961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34962 if (!SWIG_IsOK(res1)) {
34963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
34964 }
34965 arg1 = reinterpret_cast< wxWindow * >(argp1);
34966 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
34967 if (!SWIG_IsOK(res2)) {
34968 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
34969 }
34970 if (!argp2) {
34971 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
34972 }
34973 arg2 = reinterpret_cast< wxCursor * >(argp2);
34974 {
34975 PyThreadState* __tstate = wxPyBeginAllowThreads();
34976 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
34977 wxPyEndAllowThreads(__tstate);
34978 if (PyErr_Occurred()) SWIG_fail;
34979 }
34980 {
34981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34982 }
34983 return resultobj;
34984 fail:
34985 return NULL;
34986 }
34987
34988
34989 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34990 PyObject *resultobj = 0;
34991 wxWindow *arg1 = (wxWindow *) 0 ;
34992 wxCursor result;
34993 void *argp1 = 0 ;
34994 int res1 = 0 ;
34995 PyObject *swig_obj[1] ;
34996
34997 if (!args) SWIG_fail;
34998 swig_obj[0] = args;
34999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35000 if (!SWIG_IsOK(res1)) {
35001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35002 }
35003 arg1 = reinterpret_cast< wxWindow * >(argp1);
35004 {
35005 PyThreadState* __tstate = wxPyBeginAllowThreads();
35006 result = (arg1)->GetCursor();
35007 wxPyEndAllowThreads(__tstate);
35008 if (PyErr_Occurred()) SWIG_fail;
35009 }
35010 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35011 return resultobj;
35012 fail:
35013 return NULL;
35014 }
35015
35016
35017 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35018 PyObject *resultobj = 0;
35019 wxWindow *arg1 = (wxWindow *) 0 ;
35020 wxFont *arg2 = 0 ;
35021 bool result;
35022 void *argp1 = 0 ;
35023 int res1 = 0 ;
35024 void *argp2 = 0 ;
35025 int res2 = 0 ;
35026 PyObject * obj0 = 0 ;
35027 PyObject * obj1 = 0 ;
35028 char * kwnames[] = {
35029 (char *) "self",(char *) "font", NULL
35030 };
35031
35032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35034 if (!SWIG_IsOK(res1)) {
35035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35036 }
35037 arg1 = reinterpret_cast< wxWindow * >(argp1);
35038 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35039 if (!SWIG_IsOK(res2)) {
35040 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35041 }
35042 if (!argp2) {
35043 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35044 }
35045 arg2 = reinterpret_cast< wxFont * >(argp2);
35046 {
35047 PyThreadState* __tstate = wxPyBeginAllowThreads();
35048 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35049 wxPyEndAllowThreads(__tstate);
35050 if (PyErr_Occurred()) SWIG_fail;
35051 }
35052 {
35053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35054 }
35055 return resultobj;
35056 fail:
35057 return NULL;
35058 }
35059
35060
35061 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35062 PyObject *resultobj = 0;
35063 wxWindow *arg1 = (wxWindow *) 0 ;
35064 wxFont *arg2 = 0 ;
35065 void *argp1 = 0 ;
35066 int res1 = 0 ;
35067 void *argp2 = 0 ;
35068 int res2 = 0 ;
35069 PyObject * obj0 = 0 ;
35070 PyObject * obj1 = 0 ;
35071 char * kwnames[] = {
35072 (char *) "self",(char *) "font", NULL
35073 };
35074
35075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35077 if (!SWIG_IsOK(res1)) {
35078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35079 }
35080 arg1 = reinterpret_cast< wxWindow * >(argp1);
35081 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35082 if (!SWIG_IsOK(res2)) {
35083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35084 }
35085 if (!argp2) {
35086 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35087 }
35088 arg2 = reinterpret_cast< wxFont * >(argp2);
35089 {
35090 PyThreadState* __tstate = wxPyBeginAllowThreads();
35091 (arg1)->SetOwnFont((wxFont const &)*arg2);
35092 wxPyEndAllowThreads(__tstate);
35093 if (PyErr_Occurred()) SWIG_fail;
35094 }
35095 resultobj = SWIG_Py_Void();
35096 return resultobj;
35097 fail:
35098 return NULL;
35099 }
35100
35101
35102 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35103 PyObject *resultobj = 0;
35104 wxWindow *arg1 = (wxWindow *) 0 ;
35105 wxFont result;
35106 void *argp1 = 0 ;
35107 int res1 = 0 ;
35108 PyObject *swig_obj[1] ;
35109
35110 if (!args) SWIG_fail;
35111 swig_obj[0] = args;
35112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35113 if (!SWIG_IsOK(res1)) {
35114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35115 }
35116 arg1 = reinterpret_cast< wxWindow * >(argp1);
35117 {
35118 PyThreadState* __tstate = wxPyBeginAllowThreads();
35119 result = (arg1)->GetFont();
35120 wxPyEndAllowThreads(__tstate);
35121 if (PyErr_Occurred()) SWIG_fail;
35122 }
35123 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35124 return resultobj;
35125 fail:
35126 return NULL;
35127 }
35128
35129
35130 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35131 PyObject *resultobj = 0;
35132 wxWindow *arg1 = (wxWindow *) 0 ;
35133 wxCaret *arg2 = (wxCaret *) 0 ;
35134 void *argp1 = 0 ;
35135 int res1 = 0 ;
35136 int res2 = 0 ;
35137 PyObject * obj0 = 0 ;
35138 PyObject * obj1 = 0 ;
35139 char * kwnames[] = {
35140 (char *) "self",(char *) "caret", NULL
35141 };
35142
35143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35145 if (!SWIG_IsOK(res1)) {
35146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35147 }
35148 arg1 = reinterpret_cast< wxWindow * >(argp1);
35149 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35150 if (!SWIG_IsOK(res2)) {
35151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35152 }
35153 {
35154 PyThreadState* __tstate = wxPyBeginAllowThreads();
35155 (arg1)->SetCaret(arg2);
35156 wxPyEndAllowThreads(__tstate);
35157 if (PyErr_Occurred()) SWIG_fail;
35158 }
35159 resultobj = SWIG_Py_Void();
35160 return resultobj;
35161 fail:
35162 return NULL;
35163 }
35164
35165
35166 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35167 PyObject *resultobj = 0;
35168 wxWindow *arg1 = (wxWindow *) 0 ;
35169 wxCaret *result = 0 ;
35170 void *argp1 = 0 ;
35171 int res1 = 0 ;
35172 PyObject *swig_obj[1] ;
35173
35174 if (!args) SWIG_fail;
35175 swig_obj[0] = args;
35176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35177 if (!SWIG_IsOK(res1)) {
35178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35179 }
35180 arg1 = reinterpret_cast< wxWindow * >(argp1);
35181 {
35182 PyThreadState* __tstate = wxPyBeginAllowThreads();
35183 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35184 wxPyEndAllowThreads(__tstate);
35185 if (PyErr_Occurred()) SWIG_fail;
35186 }
35187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35188 return resultobj;
35189 fail:
35190 return NULL;
35191 }
35192
35193
35194 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35195 PyObject *resultobj = 0;
35196 wxWindow *arg1 = (wxWindow *) 0 ;
35197 int result;
35198 void *argp1 = 0 ;
35199 int res1 = 0 ;
35200 PyObject *swig_obj[1] ;
35201
35202 if (!args) SWIG_fail;
35203 swig_obj[0] = args;
35204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35205 if (!SWIG_IsOK(res1)) {
35206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35207 }
35208 arg1 = reinterpret_cast< wxWindow * >(argp1);
35209 {
35210 PyThreadState* __tstate = wxPyBeginAllowThreads();
35211 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35212 wxPyEndAllowThreads(__tstate);
35213 if (PyErr_Occurred()) SWIG_fail;
35214 }
35215 resultobj = SWIG_From_int(static_cast< int >(result));
35216 return resultobj;
35217 fail:
35218 return NULL;
35219 }
35220
35221
35222 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35223 PyObject *resultobj = 0;
35224 wxWindow *arg1 = (wxWindow *) 0 ;
35225 int result;
35226 void *argp1 = 0 ;
35227 int res1 = 0 ;
35228 PyObject *swig_obj[1] ;
35229
35230 if (!args) SWIG_fail;
35231 swig_obj[0] = args;
35232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35233 if (!SWIG_IsOK(res1)) {
35234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35235 }
35236 arg1 = reinterpret_cast< wxWindow * >(argp1);
35237 {
35238 PyThreadState* __tstate = wxPyBeginAllowThreads();
35239 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35240 wxPyEndAllowThreads(__tstate);
35241 if (PyErr_Occurred()) SWIG_fail;
35242 }
35243 resultobj = SWIG_From_int(static_cast< int >(result));
35244 return resultobj;
35245 fail:
35246 return NULL;
35247 }
35248
35249
35250 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35251 PyObject *resultobj = 0;
35252 wxWindow *arg1 = (wxWindow *) 0 ;
35253 wxString *arg2 = 0 ;
35254 int *arg3 = (int *) 0 ;
35255 int *arg4 = (int *) 0 ;
35256 void *argp1 = 0 ;
35257 int res1 = 0 ;
35258 bool temp2 = false ;
35259 int temp3 ;
35260 int res3 = SWIG_TMPOBJ ;
35261 int temp4 ;
35262 int res4 = SWIG_TMPOBJ ;
35263 PyObject * obj0 = 0 ;
35264 PyObject * obj1 = 0 ;
35265 char * kwnames[] = {
35266 (char *) "self",(char *) "string", NULL
35267 };
35268
35269 arg3 = &temp3;
35270 arg4 = &temp4;
35271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35273 if (!SWIG_IsOK(res1)) {
35274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35275 }
35276 arg1 = reinterpret_cast< wxWindow * >(argp1);
35277 {
35278 arg2 = wxString_in_helper(obj1);
35279 if (arg2 == NULL) SWIG_fail;
35280 temp2 = true;
35281 }
35282 {
35283 PyThreadState* __tstate = wxPyBeginAllowThreads();
35284 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35285 wxPyEndAllowThreads(__tstate);
35286 if (PyErr_Occurred()) SWIG_fail;
35287 }
35288 resultobj = SWIG_Py_Void();
35289 if (SWIG_IsTmpObj(res3)) {
35290 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35291 } else {
35292 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35293 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35294 }
35295 if (SWIG_IsTmpObj(res4)) {
35296 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35297 } else {
35298 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35299 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35300 }
35301 {
35302 if (temp2)
35303 delete arg2;
35304 }
35305 return resultobj;
35306 fail:
35307 {
35308 if (temp2)
35309 delete arg2;
35310 }
35311 return NULL;
35312 }
35313
35314
35315 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35316 PyObject *resultobj = 0;
35317 wxWindow *arg1 = (wxWindow *) 0 ;
35318 wxString *arg2 = 0 ;
35319 int *arg3 = (int *) 0 ;
35320 int *arg4 = (int *) 0 ;
35321 int *arg5 = (int *) 0 ;
35322 int *arg6 = (int *) 0 ;
35323 wxFont *arg7 = (wxFont *) NULL ;
35324 void *argp1 = 0 ;
35325 int res1 = 0 ;
35326 bool temp2 = false ;
35327 int temp3 ;
35328 int res3 = SWIG_TMPOBJ ;
35329 int temp4 ;
35330 int res4 = SWIG_TMPOBJ ;
35331 int temp5 ;
35332 int res5 = SWIG_TMPOBJ ;
35333 int temp6 ;
35334 int res6 = SWIG_TMPOBJ ;
35335 void *argp7 = 0 ;
35336 int res7 = 0 ;
35337 PyObject * obj0 = 0 ;
35338 PyObject * obj1 = 0 ;
35339 PyObject * obj2 = 0 ;
35340 char * kwnames[] = {
35341 (char *) "self",(char *) "string",(char *) "font", NULL
35342 };
35343
35344 arg3 = &temp3;
35345 arg4 = &temp4;
35346 arg5 = &temp5;
35347 arg6 = &temp6;
35348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35350 if (!SWIG_IsOK(res1)) {
35351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35352 }
35353 arg1 = reinterpret_cast< wxWindow * >(argp1);
35354 {
35355 arg2 = wxString_in_helper(obj1);
35356 if (arg2 == NULL) SWIG_fail;
35357 temp2 = true;
35358 }
35359 if (obj2) {
35360 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35361 if (!SWIG_IsOK(res7)) {
35362 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35363 }
35364 arg7 = reinterpret_cast< wxFont * >(argp7);
35365 }
35366 {
35367 PyThreadState* __tstate = wxPyBeginAllowThreads();
35368 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35369 wxPyEndAllowThreads(__tstate);
35370 if (PyErr_Occurred()) SWIG_fail;
35371 }
35372 resultobj = SWIG_Py_Void();
35373 if (SWIG_IsTmpObj(res3)) {
35374 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35375 } else {
35376 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35377 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35378 }
35379 if (SWIG_IsTmpObj(res4)) {
35380 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35381 } else {
35382 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35383 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35384 }
35385 if (SWIG_IsTmpObj(res5)) {
35386 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35387 } else {
35388 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35389 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35390 }
35391 if (SWIG_IsTmpObj(res6)) {
35392 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35393 } else {
35394 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35395 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35396 }
35397 {
35398 if (temp2)
35399 delete arg2;
35400 }
35401 return resultobj;
35402 fail:
35403 {
35404 if (temp2)
35405 delete arg2;
35406 }
35407 return NULL;
35408 }
35409
35410
35411 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35412 PyObject *resultobj = 0;
35413 wxWindow *arg1 = (wxWindow *) 0 ;
35414 int *arg2 = (int *) 0 ;
35415 int *arg3 = (int *) 0 ;
35416 void *argp1 = 0 ;
35417 int res1 = 0 ;
35418 int temp2 ;
35419 int res2 = 0 ;
35420 int temp3 ;
35421 int res3 = 0 ;
35422 PyObject * obj0 = 0 ;
35423 PyObject * obj1 = 0 ;
35424 PyObject * obj2 = 0 ;
35425 char * kwnames[] = {
35426 (char *) "self",(char *) "x",(char *) "y", NULL
35427 };
35428
35429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35431 if (!SWIG_IsOK(res1)) {
35432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35433 }
35434 arg1 = reinterpret_cast< wxWindow * >(argp1);
35435 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35436 int val;
35437 int ecode = SWIG_AsVal_int(obj1, &val);
35438 if (!SWIG_IsOK(ecode)) {
35439 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35440 }
35441 temp2 = static_cast< int >(val);
35442 arg2 = &temp2;
35443 res2 = SWIG_AddTmpMask(ecode);
35444 }
35445 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35446 int val;
35447 int ecode = SWIG_AsVal_int(obj2, &val);
35448 if (!SWIG_IsOK(ecode)) {
35449 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35450 }
35451 temp3 = static_cast< int >(val);
35452 arg3 = &temp3;
35453 res3 = SWIG_AddTmpMask(ecode);
35454 }
35455 {
35456 PyThreadState* __tstate = wxPyBeginAllowThreads();
35457 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35458 wxPyEndAllowThreads(__tstate);
35459 if (PyErr_Occurred()) SWIG_fail;
35460 }
35461 resultobj = SWIG_Py_Void();
35462 if (SWIG_IsTmpObj(res2)) {
35463 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35464 } else {
35465 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35466 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35467 }
35468 if (SWIG_IsTmpObj(res3)) {
35469 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35470 } else {
35471 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35472 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35473 }
35474 return resultobj;
35475 fail:
35476 return NULL;
35477 }
35478
35479
35480 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35481 PyObject *resultobj = 0;
35482 wxWindow *arg1 = (wxWindow *) 0 ;
35483 int *arg2 = (int *) 0 ;
35484 int *arg3 = (int *) 0 ;
35485 void *argp1 = 0 ;
35486 int res1 = 0 ;
35487 int temp2 ;
35488 int res2 = 0 ;
35489 int temp3 ;
35490 int res3 = 0 ;
35491 PyObject * obj0 = 0 ;
35492 PyObject * obj1 = 0 ;
35493 PyObject * obj2 = 0 ;
35494 char * kwnames[] = {
35495 (char *) "self",(char *) "x",(char *) "y", NULL
35496 };
35497
35498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) 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_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35502 }
35503 arg1 = reinterpret_cast< wxWindow * >(argp1);
35504 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35505 int val;
35506 int ecode = SWIG_AsVal_int(obj1, &val);
35507 if (!SWIG_IsOK(ecode)) {
35508 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35509 }
35510 temp2 = static_cast< int >(val);
35511 arg2 = &temp2;
35512 res2 = SWIG_AddTmpMask(ecode);
35513 }
35514 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35515 int val;
35516 int ecode = SWIG_AsVal_int(obj2, &val);
35517 if (!SWIG_IsOK(ecode)) {
35518 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35519 }
35520 temp3 = static_cast< int >(val);
35521 arg3 = &temp3;
35522 res3 = SWIG_AddTmpMask(ecode);
35523 }
35524 {
35525 PyThreadState* __tstate = wxPyBeginAllowThreads();
35526 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35527 wxPyEndAllowThreads(__tstate);
35528 if (PyErr_Occurred()) SWIG_fail;
35529 }
35530 resultobj = SWIG_Py_Void();
35531 if (SWIG_IsTmpObj(res2)) {
35532 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35533 } else {
35534 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35535 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35536 }
35537 if (SWIG_IsTmpObj(res3)) {
35538 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35539 } else {
35540 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35541 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35542 }
35543 return resultobj;
35544 fail:
35545 return NULL;
35546 }
35547
35548
35549 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35550 PyObject *resultobj = 0;
35551 wxWindow *arg1 = (wxWindow *) 0 ;
35552 wxPoint *arg2 = 0 ;
35553 wxPoint result;
35554 void *argp1 = 0 ;
35555 int res1 = 0 ;
35556 wxPoint temp2 ;
35557 PyObject * obj0 = 0 ;
35558 PyObject * obj1 = 0 ;
35559 char * kwnames[] = {
35560 (char *) "self",(char *) "pt", NULL
35561 };
35562
35563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35565 if (!SWIG_IsOK(res1)) {
35566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35567 }
35568 arg1 = reinterpret_cast< wxWindow * >(argp1);
35569 {
35570 arg2 = &temp2;
35571 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35572 }
35573 {
35574 PyThreadState* __tstate = wxPyBeginAllowThreads();
35575 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35576 wxPyEndAllowThreads(__tstate);
35577 if (PyErr_Occurred()) SWIG_fail;
35578 }
35579 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35580 return resultobj;
35581 fail:
35582 return NULL;
35583 }
35584
35585
35586 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35587 PyObject *resultobj = 0;
35588 wxWindow *arg1 = (wxWindow *) 0 ;
35589 wxPoint *arg2 = 0 ;
35590 wxPoint result;
35591 void *argp1 = 0 ;
35592 int res1 = 0 ;
35593 wxPoint temp2 ;
35594 PyObject * obj0 = 0 ;
35595 PyObject * obj1 = 0 ;
35596 char * kwnames[] = {
35597 (char *) "self",(char *) "pt", NULL
35598 };
35599
35600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35602 if (!SWIG_IsOK(res1)) {
35603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35604 }
35605 arg1 = reinterpret_cast< wxWindow * >(argp1);
35606 {
35607 arg2 = &temp2;
35608 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35609 }
35610 {
35611 PyThreadState* __tstate = wxPyBeginAllowThreads();
35612 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35613 wxPyEndAllowThreads(__tstate);
35614 if (PyErr_Occurred()) SWIG_fail;
35615 }
35616 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35617 return resultobj;
35618 fail:
35619 return NULL;
35620 }
35621
35622
35623 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35624 PyObject *resultobj = 0;
35625 wxWindow *arg1 = (wxWindow *) 0 ;
35626 int arg2 ;
35627 int arg3 ;
35628 wxHitTest result;
35629 void *argp1 = 0 ;
35630 int res1 = 0 ;
35631 int val2 ;
35632 int ecode2 = 0 ;
35633 int val3 ;
35634 int ecode3 = 0 ;
35635 PyObject * obj0 = 0 ;
35636 PyObject * obj1 = 0 ;
35637 PyObject * obj2 = 0 ;
35638 char * kwnames[] = {
35639 (char *) "self",(char *) "x",(char *) "y", NULL
35640 };
35641
35642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35644 if (!SWIG_IsOK(res1)) {
35645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35646 }
35647 arg1 = reinterpret_cast< wxWindow * >(argp1);
35648 ecode2 = SWIG_AsVal_int(obj1, &val2);
35649 if (!SWIG_IsOK(ecode2)) {
35650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35651 }
35652 arg2 = static_cast< int >(val2);
35653 ecode3 = SWIG_AsVal_int(obj2, &val3);
35654 if (!SWIG_IsOK(ecode3)) {
35655 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35656 }
35657 arg3 = static_cast< int >(val3);
35658 {
35659 PyThreadState* __tstate = wxPyBeginAllowThreads();
35660 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35661 wxPyEndAllowThreads(__tstate);
35662 if (PyErr_Occurred()) SWIG_fail;
35663 }
35664 resultobj = SWIG_From_int(static_cast< int >(result));
35665 return resultobj;
35666 fail:
35667 return NULL;
35668 }
35669
35670
35671 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35672 PyObject *resultobj = 0;
35673 wxWindow *arg1 = (wxWindow *) 0 ;
35674 wxPoint *arg2 = 0 ;
35675 wxHitTest result;
35676 void *argp1 = 0 ;
35677 int res1 = 0 ;
35678 wxPoint temp2 ;
35679 PyObject * obj0 = 0 ;
35680 PyObject * obj1 = 0 ;
35681 char * kwnames[] = {
35682 (char *) "self",(char *) "pt", NULL
35683 };
35684
35685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35687 if (!SWIG_IsOK(res1)) {
35688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35689 }
35690 arg1 = reinterpret_cast< wxWindow * >(argp1);
35691 {
35692 arg2 = &temp2;
35693 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35694 }
35695 {
35696 PyThreadState* __tstate = wxPyBeginAllowThreads();
35697 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35698 wxPyEndAllowThreads(__tstate);
35699 if (PyErr_Occurred()) SWIG_fail;
35700 }
35701 resultobj = SWIG_From_int(static_cast< int >(result));
35702 return resultobj;
35703 fail:
35704 return NULL;
35705 }
35706
35707
35708 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35709 PyObject *resultobj = 0;
35710 wxWindow *arg1 = (wxWindow *) 0 ;
35711 long arg2 ;
35712 wxBorder result;
35713 void *argp1 = 0 ;
35714 int res1 = 0 ;
35715 long val2 ;
35716 int ecode2 = 0 ;
35717
35718 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35720 if (!SWIG_IsOK(res1)) {
35721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35722 }
35723 arg1 = reinterpret_cast< wxWindow * >(argp1);
35724 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35725 if (!SWIG_IsOK(ecode2)) {
35726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35727 }
35728 arg2 = static_cast< long >(val2);
35729 {
35730 PyThreadState* __tstate = wxPyBeginAllowThreads();
35731 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35732 wxPyEndAllowThreads(__tstate);
35733 if (PyErr_Occurred()) SWIG_fail;
35734 }
35735 resultobj = SWIG_From_int(static_cast< int >(result));
35736 return resultobj;
35737 fail:
35738 return NULL;
35739 }
35740
35741
35742 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35743 PyObject *resultobj = 0;
35744 wxWindow *arg1 = (wxWindow *) 0 ;
35745 wxBorder result;
35746 void *argp1 = 0 ;
35747 int res1 = 0 ;
35748
35749 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35751 if (!SWIG_IsOK(res1)) {
35752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35753 }
35754 arg1 = reinterpret_cast< wxWindow * >(argp1);
35755 {
35756 PyThreadState* __tstate = wxPyBeginAllowThreads();
35757 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35758 wxPyEndAllowThreads(__tstate);
35759 if (PyErr_Occurred()) SWIG_fail;
35760 }
35761 resultobj = SWIG_From_int(static_cast< int >(result));
35762 return resultobj;
35763 fail:
35764 return NULL;
35765 }
35766
35767
35768 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35769 int argc;
35770 PyObject *argv[3];
35771
35772 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35773 --argc;
35774 if (argc == 1) {
35775 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35776 }
35777 if (argc == 2) {
35778 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35779 }
35780
35781 fail:
35782 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35783 return NULL;
35784 }
35785
35786
35787 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35788 PyObject *resultobj = 0;
35789 wxWindow *arg1 = (wxWindow *) 0 ;
35790 long arg2 = (long) wxUPDATE_UI_NONE ;
35791 void *argp1 = 0 ;
35792 int res1 = 0 ;
35793 long val2 ;
35794 int ecode2 = 0 ;
35795 PyObject * obj0 = 0 ;
35796 PyObject * obj1 = 0 ;
35797 char * kwnames[] = {
35798 (char *) "self",(char *) "flags", NULL
35799 };
35800
35801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35803 if (!SWIG_IsOK(res1)) {
35804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35805 }
35806 arg1 = reinterpret_cast< wxWindow * >(argp1);
35807 if (obj1) {
35808 ecode2 = SWIG_AsVal_long(obj1, &val2);
35809 if (!SWIG_IsOK(ecode2)) {
35810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35811 }
35812 arg2 = static_cast< long >(val2);
35813 }
35814 {
35815 PyThreadState* __tstate = wxPyBeginAllowThreads();
35816 (arg1)->UpdateWindowUI(arg2);
35817 wxPyEndAllowThreads(__tstate);
35818 if (PyErr_Occurred()) SWIG_fail;
35819 }
35820 resultobj = SWIG_Py_Void();
35821 return resultobj;
35822 fail:
35823 return NULL;
35824 }
35825
35826
35827 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35828 PyObject *resultobj = 0;
35829 wxWindow *arg1 = (wxWindow *) 0 ;
35830 wxMenu *arg2 = (wxMenu *) 0 ;
35831 int arg3 = (int) -1 ;
35832 int arg4 = (int) -1 ;
35833 bool result;
35834 void *argp1 = 0 ;
35835 int res1 = 0 ;
35836 void *argp2 = 0 ;
35837 int res2 = 0 ;
35838 int val3 ;
35839 int ecode3 = 0 ;
35840 int val4 ;
35841 int ecode4 = 0 ;
35842 PyObject * obj0 = 0 ;
35843 PyObject * obj1 = 0 ;
35844 PyObject * obj2 = 0 ;
35845 PyObject * obj3 = 0 ;
35846 char * kwnames[] = {
35847 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
35848 };
35849
35850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35852 if (!SWIG_IsOK(res1)) {
35853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
35854 }
35855 arg1 = reinterpret_cast< wxWindow * >(argp1);
35856 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35857 if (!SWIG_IsOK(res2)) {
35858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
35859 }
35860 arg2 = reinterpret_cast< wxMenu * >(argp2);
35861 if (obj2) {
35862 ecode3 = SWIG_AsVal_int(obj2, &val3);
35863 if (!SWIG_IsOK(ecode3)) {
35864 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
35865 }
35866 arg3 = static_cast< int >(val3);
35867 }
35868 if (obj3) {
35869 ecode4 = SWIG_AsVal_int(obj3, &val4);
35870 if (!SWIG_IsOK(ecode4)) {
35871 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
35872 }
35873 arg4 = static_cast< int >(val4);
35874 }
35875 {
35876 PyThreadState* __tstate = wxPyBeginAllowThreads();
35877 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
35878 wxPyEndAllowThreads(__tstate);
35879 if (PyErr_Occurred()) SWIG_fail;
35880 }
35881 {
35882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35883 }
35884 return resultobj;
35885 fail:
35886 return NULL;
35887 }
35888
35889
35890 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35891 PyObject *resultobj = 0;
35892 wxWindow *arg1 = (wxWindow *) 0 ;
35893 wxMenu *arg2 = (wxMenu *) 0 ;
35894 wxPoint const &arg3_defvalue = wxDefaultPosition ;
35895 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
35896 bool result;
35897 void *argp1 = 0 ;
35898 int res1 = 0 ;
35899 void *argp2 = 0 ;
35900 int res2 = 0 ;
35901 wxPoint temp3 ;
35902 PyObject * obj0 = 0 ;
35903 PyObject * obj1 = 0 ;
35904 PyObject * obj2 = 0 ;
35905 char * kwnames[] = {
35906 (char *) "self",(char *) "menu",(char *) "pos", NULL
35907 };
35908
35909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35911 if (!SWIG_IsOK(res1)) {
35912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
35913 }
35914 arg1 = reinterpret_cast< wxWindow * >(argp1);
35915 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35916 if (!SWIG_IsOK(res2)) {
35917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
35918 }
35919 arg2 = reinterpret_cast< wxMenu * >(argp2);
35920 if (obj2) {
35921 {
35922 arg3 = &temp3;
35923 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
35924 }
35925 }
35926 {
35927 PyThreadState* __tstate = wxPyBeginAllowThreads();
35928 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
35929 wxPyEndAllowThreads(__tstate);
35930 if (PyErr_Occurred()) SWIG_fail;
35931 }
35932 {
35933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35934 }
35935 return resultobj;
35936 fail:
35937 return NULL;
35938 }
35939
35940
35941 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35942 PyObject *resultobj = 0;
35943 wxWindow *arg1 = (wxWindow *) 0 ;
35944 long result;
35945 void *argp1 = 0 ;
35946 int res1 = 0 ;
35947 PyObject *swig_obj[1] ;
35948
35949 if (!args) SWIG_fail;
35950 swig_obj[0] = args;
35951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35952 if (!SWIG_IsOK(res1)) {
35953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
35954 }
35955 arg1 = reinterpret_cast< wxWindow * >(argp1);
35956 {
35957 PyThreadState* __tstate = wxPyBeginAllowThreads();
35958 result = (long)wxWindow_GetHandle(arg1);
35959 wxPyEndAllowThreads(__tstate);
35960 if (PyErr_Occurred()) SWIG_fail;
35961 }
35962 resultobj = SWIG_From_long(static_cast< long >(result));
35963 return resultobj;
35964 fail:
35965 return NULL;
35966 }
35967
35968
35969 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35970 PyObject *resultobj = 0;
35971 wxWindow *arg1 = (wxWindow *) 0 ;
35972 long arg2 ;
35973 void *argp1 = 0 ;
35974 int res1 = 0 ;
35975 long val2 ;
35976 int ecode2 = 0 ;
35977 PyObject * obj0 = 0 ;
35978 PyObject * obj1 = 0 ;
35979 char * kwnames[] = {
35980 (char *) "self",(char *) "handle", NULL
35981 };
35982
35983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
35984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35985 if (!SWIG_IsOK(res1)) {
35986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
35987 }
35988 arg1 = reinterpret_cast< wxWindow * >(argp1);
35989 ecode2 = SWIG_AsVal_long(obj1, &val2);
35990 if (!SWIG_IsOK(ecode2)) {
35991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
35992 }
35993 arg2 = static_cast< long >(val2);
35994 {
35995 PyThreadState* __tstate = wxPyBeginAllowThreads();
35996 wxWindow_AssociateHandle(arg1,arg2);
35997 wxPyEndAllowThreads(__tstate);
35998 if (PyErr_Occurred()) SWIG_fail;
35999 }
36000 resultobj = SWIG_Py_Void();
36001 return resultobj;
36002 fail:
36003 return NULL;
36004 }
36005
36006
36007 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36008 PyObject *resultobj = 0;
36009 wxWindow *arg1 = (wxWindow *) 0 ;
36010 void *argp1 = 0 ;
36011 int res1 = 0 ;
36012 PyObject *swig_obj[1] ;
36013
36014 if (!args) SWIG_fail;
36015 swig_obj[0] = args;
36016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36017 if (!SWIG_IsOK(res1)) {
36018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36019 }
36020 arg1 = reinterpret_cast< wxWindow * >(argp1);
36021 {
36022 PyThreadState* __tstate = wxPyBeginAllowThreads();
36023 (arg1)->DissociateHandle();
36024 wxPyEndAllowThreads(__tstate);
36025 if (PyErr_Occurred()) SWIG_fail;
36026 }
36027 resultobj = SWIG_Py_Void();
36028 return resultobj;
36029 fail:
36030 return NULL;
36031 }
36032
36033
36034 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36035 PyObject *resultobj = 0;
36036 wxWindow *arg1 = (wxWindow *) 0 ;
36037 int arg2 ;
36038 bool result;
36039 void *argp1 = 0 ;
36040 int res1 = 0 ;
36041 int val2 ;
36042 int ecode2 = 0 ;
36043 PyObject * obj0 = 0 ;
36044 PyObject * obj1 = 0 ;
36045 char * kwnames[] = {
36046 (char *) "self",(char *) "orient", NULL
36047 };
36048
36049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36051 if (!SWIG_IsOK(res1)) {
36052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36053 }
36054 arg1 = reinterpret_cast< wxWindow * >(argp1);
36055 ecode2 = SWIG_AsVal_int(obj1, &val2);
36056 if (!SWIG_IsOK(ecode2)) {
36057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36058 }
36059 arg2 = static_cast< int >(val2);
36060 {
36061 PyThreadState* __tstate = wxPyBeginAllowThreads();
36062 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36063 wxPyEndAllowThreads(__tstate);
36064 if (PyErr_Occurred()) SWIG_fail;
36065 }
36066 {
36067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36068 }
36069 return resultobj;
36070 fail:
36071 return NULL;
36072 }
36073
36074
36075 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36076 PyObject *resultobj = 0;
36077 wxWindow *arg1 = (wxWindow *) 0 ;
36078 int arg2 ;
36079 int arg3 ;
36080 int arg4 ;
36081 int arg5 ;
36082 bool arg6 = (bool) true ;
36083 void *argp1 = 0 ;
36084 int res1 = 0 ;
36085 int val2 ;
36086 int ecode2 = 0 ;
36087 int val3 ;
36088 int ecode3 = 0 ;
36089 int val4 ;
36090 int ecode4 = 0 ;
36091 int val5 ;
36092 int ecode5 = 0 ;
36093 bool val6 ;
36094 int ecode6 = 0 ;
36095 PyObject * obj0 = 0 ;
36096 PyObject * obj1 = 0 ;
36097 PyObject * obj2 = 0 ;
36098 PyObject * obj3 = 0 ;
36099 PyObject * obj4 = 0 ;
36100 PyObject * obj5 = 0 ;
36101 char * kwnames[] = {
36102 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36103 };
36104
36105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36107 if (!SWIG_IsOK(res1)) {
36108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36109 }
36110 arg1 = reinterpret_cast< wxWindow * >(argp1);
36111 ecode2 = SWIG_AsVal_int(obj1, &val2);
36112 if (!SWIG_IsOK(ecode2)) {
36113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36114 }
36115 arg2 = static_cast< int >(val2);
36116 ecode3 = SWIG_AsVal_int(obj2, &val3);
36117 if (!SWIG_IsOK(ecode3)) {
36118 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36119 }
36120 arg3 = static_cast< int >(val3);
36121 ecode4 = SWIG_AsVal_int(obj3, &val4);
36122 if (!SWIG_IsOK(ecode4)) {
36123 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36124 }
36125 arg4 = static_cast< int >(val4);
36126 ecode5 = SWIG_AsVal_int(obj4, &val5);
36127 if (!SWIG_IsOK(ecode5)) {
36128 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36129 }
36130 arg5 = static_cast< int >(val5);
36131 if (obj5) {
36132 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36133 if (!SWIG_IsOK(ecode6)) {
36134 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36135 }
36136 arg6 = static_cast< bool >(val6);
36137 }
36138 {
36139 PyThreadState* __tstate = wxPyBeginAllowThreads();
36140 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36141 wxPyEndAllowThreads(__tstate);
36142 if (PyErr_Occurred()) SWIG_fail;
36143 }
36144 resultobj = SWIG_Py_Void();
36145 return resultobj;
36146 fail:
36147 return NULL;
36148 }
36149
36150
36151 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36152 PyObject *resultobj = 0;
36153 wxWindow *arg1 = (wxWindow *) 0 ;
36154 int arg2 ;
36155 int arg3 ;
36156 bool arg4 = (bool) true ;
36157 void *argp1 = 0 ;
36158 int res1 = 0 ;
36159 int val2 ;
36160 int ecode2 = 0 ;
36161 int val3 ;
36162 int ecode3 = 0 ;
36163 bool val4 ;
36164 int ecode4 = 0 ;
36165 PyObject * obj0 = 0 ;
36166 PyObject * obj1 = 0 ;
36167 PyObject * obj2 = 0 ;
36168 PyObject * obj3 = 0 ;
36169 char * kwnames[] = {
36170 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36171 };
36172
36173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36175 if (!SWIG_IsOK(res1)) {
36176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36177 }
36178 arg1 = reinterpret_cast< wxWindow * >(argp1);
36179 ecode2 = SWIG_AsVal_int(obj1, &val2);
36180 if (!SWIG_IsOK(ecode2)) {
36181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36182 }
36183 arg2 = static_cast< int >(val2);
36184 ecode3 = SWIG_AsVal_int(obj2, &val3);
36185 if (!SWIG_IsOK(ecode3)) {
36186 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36187 }
36188 arg3 = static_cast< int >(val3);
36189 if (obj3) {
36190 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36191 if (!SWIG_IsOK(ecode4)) {
36192 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36193 }
36194 arg4 = static_cast< bool >(val4);
36195 }
36196 {
36197 PyThreadState* __tstate = wxPyBeginAllowThreads();
36198 (arg1)->SetScrollPos(arg2,arg3,arg4);
36199 wxPyEndAllowThreads(__tstate);
36200 if (PyErr_Occurred()) SWIG_fail;
36201 }
36202 resultobj = SWIG_Py_Void();
36203 return resultobj;
36204 fail:
36205 return NULL;
36206 }
36207
36208
36209 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36210 PyObject *resultobj = 0;
36211 wxWindow *arg1 = (wxWindow *) 0 ;
36212 int arg2 ;
36213 int result;
36214 void *argp1 = 0 ;
36215 int res1 = 0 ;
36216 int val2 ;
36217 int ecode2 = 0 ;
36218 PyObject * obj0 = 0 ;
36219 PyObject * obj1 = 0 ;
36220 char * kwnames[] = {
36221 (char *) "self",(char *) "orientation", NULL
36222 };
36223
36224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36226 if (!SWIG_IsOK(res1)) {
36227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36228 }
36229 arg1 = reinterpret_cast< wxWindow * >(argp1);
36230 ecode2 = SWIG_AsVal_int(obj1, &val2);
36231 if (!SWIG_IsOK(ecode2)) {
36232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36233 }
36234 arg2 = static_cast< int >(val2);
36235 {
36236 PyThreadState* __tstate = wxPyBeginAllowThreads();
36237 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36238 wxPyEndAllowThreads(__tstate);
36239 if (PyErr_Occurred()) SWIG_fail;
36240 }
36241 resultobj = SWIG_From_int(static_cast< int >(result));
36242 return resultobj;
36243 fail:
36244 return NULL;
36245 }
36246
36247
36248 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36249 PyObject *resultobj = 0;
36250 wxWindow *arg1 = (wxWindow *) 0 ;
36251 int arg2 ;
36252 int result;
36253 void *argp1 = 0 ;
36254 int res1 = 0 ;
36255 int val2 ;
36256 int ecode2 = 0 ;
36257 PyObject * obj0 = 0 ;
36258 PyObject * obj1 = 0 ;
36259 char * kwnames[] = {
36260 (char *) "self",(char *) "orientation", NULL
36261 };
36262
36263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36265 if (!SWIG_IsOK(res1)) {
36266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36267 }
36268 arg1 = reinterpret_cast< wxWindow * >(argp1);
36269 ecode2 = SWIG_AsVal_int(obj1, &val2);
36270 if (!SWIG_IsOK(ecode2)) {
36271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36272 }
36273 arg2 = static_cast< int >(val2);
36274 {
36275 PyThreadState* __tstate = wxPyBeginAllowThreads();
36276 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36277 wxPyEndAllowThreads(__tstate);
36278 if (PyErr_Occurred()) SWIG_fail;
36279 }
36280 resultobj = SWIG_From_int(static_cast< int >(result));
36281 return resultobj;
36282 fail:
36283 return NULL;
36284 }
36285
36286
36287 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36288 PyObject *resultobj = 0;
36289 wxWindow *arg1 = (wxWindow *) 0 ;
36290 int arg2 ;
36291 int result;
36292 void *argp1 = 0 ;
36293 int res1 = 0 ;
36294 int val2 ;
36295 int ecode2 = 0 ;
36296 PyObject * obj0 = 0 ;
36297 PyObject * obj1 = 0 ;
36298 char * kwnames[] = {
36299 (char *) "self",(char *) "orientation", NULL
36300 };
36301
36302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36304 if (!SWIG_IsOK(res1)) {
36305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36306 }
36307 arg1 = reinterpret_cast< wxWindow * >(argp1);
36308 ecode2 = SWIG_AsVal_int(obj1, &val2);
36309 if (!SWIG_IsOK(ecode2)) {
36310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36311 }
36312 arg2 = static_cast< int >(val2);
36313 {
36314 PyThreadState* __tstate = wxPyBeginAllowThreads();
36315 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36316 wxPyEndAllowThreads(__tstate);
36317 if (PyErr_Occurred()) SWIG_fail;
36318 }
36319 resultobj = SWIG_From_int(static_cast< int >(result));
36320 return resultobj;
36321 fail:
36322 return NULL;
36323 }
36324
36325
36326 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36327 PyObject *resultobj = 0;
36328 wxWindow *arg1 = (wxWindow *) 0 ;
36329 int arg2 ;
36330 int arg3 ;
36331 wxRect *arg4 = (wxRect *) NULL ;
36332 void *argp1 = 0 ;
36333 int res1 = 0 ;
36334 int val2 ;
36335 int ecode2 = 0 ;
36336 int val3 ;
36337 int ecode3 = 0 ;
36338 void *argp4 = 0 ;
36339 int res4 = 0 ;
36340 PyObject * obj0 = 0 ;
36341 PyObject * obj1 = 0 ;
36342 PyObject * obj2 = 0 ;
36343 PyObject * obj3 = 0 ;
36344 char * kwnames[] = {
36345 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36346 };
36347
36348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36350 if (!SWIG_IsOK(res1)) {
36351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36352 }
36353 arg1 = reinterpret_cast< wxWindow * >(argp1);
36354 ecode2 = SWIG_AsVal_int(obj1, &val2);
36355 if (!SWIG_IsOK(ecode2)) {
36356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36357 }
36358 arg2 = static_cast< int >(val2);
36359 ecode3 = SWIG_AsVal_int(obj2, &val3);
36360 if (!SWIG_IsOK(ecode3)) {
36361 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36362 }
36363 arg3 = static_cast< int >(val3);
36364 if (obj3) {
36365 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36366 if (!SWIG_IsOK(res4)) {
36367 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36368 }
36369 arg4 = reinterpret_cast< wxRect * >(argp4);
36370 }
36371 {
36372 PyThreadState* __tstate = wxPyBeginAllowThreads();
36373 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36374 wxPyEndAllowThreads(__tstate);
36375 if (PyErr_Occurred()) SWIG_fail;
36376 }
36377 resultobj = SWIG_Py_Void();
36378 return resultobj;
36379 fail:
36380 return NULL;
36381 }
36382
36383
36384 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36385 PyObject *resultobj = 0;
36386 wxWindow *arg1 = (wxWindow *) 0 ;
36387 int arg2 ;
36388 bool result;
36389 void *argp1 = 0 ;
36390 int res1 = 0 ;
36391 int val2 ;
36392 int ecode2 = 0 ;
36393 PyObject * obj0 = 0 ;
36394 PyObject * obj1 = 0 ;
36395 char * kwnames[] = {
36396 (char *) "self",(char *) "lines", NULL
36397 };
36398
36399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36401 if (!SWIG_IsOK(res1)) {
36402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36403 }
36404 arg1 = reinterpret_cast< wxWindow * >(argp1);
36405 ecode2 = SWIG_AsVal_int(obj1, &val2);
36406 if (!SWIG_IsOK(ecode2)) {
36407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36408 }
36409 arg2 = static_cast< int >(val2);
36410 {
36411 PyThreadState* __tstate = wxPyBeginAllowThreads();
36412 result = (bool)(arg1)->ScrollLines(arg2);
36413 wxPyEndAllowThreads(__tstate);
36414 if (PyErr_Occurred()) SWIG_fail;
36415 }
36416 {
36417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36418 }
36419 return resultobj;
36420 fail:
36421 return NULL;
36422 }
36423
36424
36425 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36426 PyObject *resultobj = 0;
36427 wxWindow *arg1 = (wxWindow *) 0 ;
36428 int arg2 ;
36429 bool result;
36430 void *argp1 = 0 ;
36431 int res1 = 0 ;
36432 int val2 ;
36433 int ecode2 = 0 ;
36434 PyObject * obj0 = 0 ;
36435 PyObject * obj1 = 0 ;
36436 char * kwnames[] = {
36437 (char *) "self",(char *) "pages", NULL
36438 };
36439
36440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36442 if (!SWIG_IsOK(res1)) {
36443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36444 }
36445 arg1 = reinterpret_cast< wxWindow * >(argp1);
36446 ecode2 = SWIG_AsVal_int(obj1, &val2);
36447 if (!SWIG_IsOK(ecode2)) {
36448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36449 }
36450 arg2 = static_cast< int >(val2);
36451 {
36452 PyThreadState* __tstate = wxPyBeginAllowThreads();
36453 result = (bool)(arg1)->ScrollPages(arg2);
36454 wxPyEndAllowThreads(__tstate);
36455 if (PyErr_Occurred()) SWIG_fail;
36456 }
36457 {
36458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36459 }
36460 return resultobj;
36461 fail:
36462 return NULL;
36463 }
36464
36465
36466 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36467 PyObject *resultobj = 0;
36468 wxWindow *arg1 = (wxWindow *) 0 ;
36469 bool result;
36470 void *argp1 = 0 ;
36471 int res1 = 0 ;
36472 PyObject *swig_obj[1] ;
36473
36474 if (!args) SWIG_fail;
36475 swig_obj[0] = args;
36476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36477 if (!SWIG_IsOK(res1)) {
36478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36479 }
36480 arg1 = reinterpret_cast< wxWindow * >(argp1);
36481 {
36482 PyThreadState* __tstate = wxPyBeginAllowThreads();
36483 result = (bool)(arg1)->LineUp();
36484 wxPyEndAllowThreads(__tstate);
36485 if (PyErr_Occurred()) SWIG_fail;
36486 }
36487 {
36488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36489 }
36490 return resultobj;
36491 fail:
36492 return NULL;
36493 }
36494
36495
36496 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36497 PyObject *resultobj = 0;
36498 wxWindow *arg1 = (wxWindow *) 0 ;
36499 bool result;
36500 void *argp1 = 0 ;
36501 int res1 = 0 ;
36502 PyObject *swig_obj[1] ;
36503
36504 if (!args) SWIG_fail;
36505 swig_obj[0] = args;
36506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36507 if (!SWIG_IsOK(res1)) {
36508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36509 }
36510 arg1 = reinterpret_cast< wxWindow * >(argp1);
36511 {
36512 PyThreadState* __tstate = wxPyBeginAllowThreads();
36513 result = (bool)(arg1)->LineDown();
36514 wxPyEndAllowThreads(__tstate);
36515 if (PyErr_Occurred()) SWIG_fail;
36516 }
36517 {
36518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36519 }
36520 return resultobj;
36521 fail:
36522 return NULL;
36523 }
36524
36525
36526 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36527 PyObject *resultobj = 0;
36528 wxWindow *arg1 = (wxWindow *) 0 ;
36529 bool result;
36530 void *argp1 = 0 ;
36531 int res1 = 0 ;
36532 PyObject *swig_obj[1] ;
36533
36534 if (!args) SWIG_fail;
36535 swig_obj[0] = args;
36536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36537 if (!SWIG_IsOK(res1)) {
36538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36539 }
36540 arg1 = reinterpret_cast< wxWindow * >(argp1);
36541 {
36542 PyThreadState* __tstate = wxPyBeginAllowThreads();
36543 result = (bool)(arg1)->PageUp();
36544 wxPyEndAllowThreads(__tstate);
36545 if (PyErr_Occurred()) SWIG_fail;
36546 }
36547 {
36548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36549 }
36550 return resultobj;
36551 fail:
36552 return NULL;
36553 }
36554
36555
36556 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36557 PyObject *resultobj = 0;
36558 wxWindow *arg1 = (wxWindow *) 0 ;
36559 bool result;
36560 void *argp1 = 0 ;
36561 int res1 = 0 ;
36562 PyObject *swig_obj[1] ;
36563
36564 if (!args) SWIG_fail;
36565 swig_obj[0] = args;
36566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36567 if (!SWIG_IsOK(res1)) {
36568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36569 }
36570 arg1 = reinterpret_cast< wxWindow * >(argp1);
36571 {
36572 PyThreadState* __tstate = wxPyBeginAllowThreads();
36573 result = (bool)(arg1)->PageDown();
36574 wxPyEndAllowThreads(__tstate);
36575 if (PyErr_Occurred()) SWIG_fail;
36576 }
36577 {
36578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36579 }
36580 return resultobj;
36581 fail:
36582 return NULL;
36583 }
36584
36585
36586 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36587 PyObject *resultobj = 0;
36588 wxWindow *arg1 = (wxWindow *) 0 ;
36589 wxString *arg2 = 0 ;
36590 void *argp1 = 0 ;
36591 int res1 = 0 ;
36592 bool temp2 = false ;
36593 PyObject * obj0 = 0 ;
36594 PyObject * obj1 = 0 ;
36595 char * kwnames[] = {
36596 (char *) "self",(char *) "text", NULL
36597 };
36598
36599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36601 if (!SWIG_IsOK(res1)) {
36602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36603 }
36604 arg1 = reinterpret_cast< wxWindow * >(argp1);
36605 {
36606 arg2 = wxString_in_helper(obj1);
36607 if (arg2 == NULL) SWIG_fail;
36608 temp2 = true;
36609 }
36610 {
36611 PyThreadState* __tstate = wxPyBeginAllowThreads();
36612 (arg1)->SetHelpText((wxString const &)*arg2);
36613 wxPyEndAllowThreads(__tstate);
36614 if (PyErr_Occurred()) SWIG_fail;
36615 }
36616 resultobj = SWIG_Py_Void();
36617 {
36618 if (temp2)
36619 delete arg2;
36620 }
36621 return resultobj;
36622 fail:
36623 {
36624 if (temp2)
36625 delete arg2;
36626 }
36627 return NULL;
36628 }
36629
36630
36631 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36632 PyObject *resultobj = 0;
36633 wxWindow *arg1 = (wxWindow *) 0 ;
36634 wxString *arg2 = 0 ;
36635 void *argp1 = 0 ;
36636 int res1 = 0 ;
36637 bool temp2 = false ;
36638 PyObject * obj0 = 0 ;
36639 PyObject * obj1 = 0 ;
36640 char * kwnames[] = {
36641 (char *) "self",(char *) "text", NULL
36642 };
36643
36644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36646 if (!SWIG_IsOK(res1)) {
36647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36648 }
36649 arg1 = reinterpret_cast< wxWindow * >(argp1);
36650 {
36651 arg2 = wxString_in_helper(obj1);
36652 if (arg2 == NULL) SWIG_fail;
36653 temp2 = true;
36654 }
36655 {
36656 PyThreadState* __tstate = wxPyBeginAllowThreads();
36657 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36658 wxPyEndAllowThreads(__tstate);
36659 if (PyErr_Occurred()) SWIG_fail;
36660 }
36661 resultobj = SWIG_Py_Void();
36662 {
36663 if (temp2)
36664 delete arg2;
36665 }
36666 return resultobj;
36667 fail:
36668 {
36669 if (temp2)
36670 delete arg2;
36671 }
36672 return NULL;
36673 }
36674
36675
36676 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36677 PyObject *resultobj = 0;
36678 wxWindow *arg1 = (wxWindow *) 0 ;
36679 wxString result;
36680 void *argp1 = 0 ;
36681 int res1 = 0 ;
36682 PyObject *swig_obj[1] ;
36683
36684 if (!args) SWIG_fail;
36685 swig_obj[0] = args;
36686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36687 if (!SWIG_IsOK(res1)) {
36688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36689 }
36690 arg1 = reinterpret_cast< wxWindow * >(argp1);
36691 {
36692 PyThreadState* __tstate = wxPyBeginAllowThreads();
36693 result = ((wxWindow const *)arg1)->GetHelpText();
36694 wxPyEndAllowThreads(__tstate);
36695 if (PyErr_Occurred()) SWIG_fail;
36696 }
36697 {
36698 #if wxUSE_UNICODE
36699 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36700 #else
36701 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36702 #endif
36703 }
36704 return resultobj;
36705 fail:
36706 return NULL;
36707 }
36708
36709
36710 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36711 PyObject *resultobj = 0;
36712 wxWindow *arg1 = (wxWindow *) 0 ;
36713 wxString *arg2 = 0 ;
36714 void *argp1 = 0 ;
36715 int res1 = 0 ;
36716 bool temp2 = false ;
36717 PyObject * obj0 = 0 ;
36718 PyObject * obj1 = 0 ;
36719 char * kwnames[] = {
36720 (char *) "self",(char *) "tip", NULL
36721 };
36722
36723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36725 if (!SWIG_IsOK(res1)) {
36726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36727 }
36728 arg1 = reinterpret_cast< wxWindow * >(argp1);
36729 {
36730 arg2 = wxString_in_helper(obj1);
36731 if (arg2 == NULL) SWIG_fail;
36732 temp2 = true;
36733 }
36734 {
36735 PyThreadState* __tstate = wxPyBeginAllowThreads();
36736 (arg1)->SetToolTip((wxString const &)*arg2);
36737 wxPyEndAllowThreads(__tstate);
36738 if (PyErr_Occurred()) SWIG_fail;
36739 }
36740 resultobj = SWIG_Py_Void();
36741 {
36742 if (temp2)
36743 delete arg2;
36744 }
36745 return resultobj;
36746 fail:
36747 {
36748 if (temp2)
36749 delete arg2;
36750 }
36751 return NULL;
36752 }
36753
36754
36755 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36756 PyObject *resultobj = 0;
36757 wxWindow *arg1 = (wxWindow *) 0 ;
36758 wxToolTip *arg2 = (wxToolTip *) 0 ;
36759 void *argp1 = 0 ;
36760 int res1 = 0 ;
36761 int res2 = 0 ;
36762 PyObject * obj0 = 0 ;
36763 PyObject * obj1 = 0 ;
36764 char * kwnames[] = {
36765 (char *) "self",(char *) "tip", NULL
36766 };
36767
36768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36770 if (!SWIG_IsOK(res1)) {
36771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36772 }
36773 arg1 = reinterpret_cast< wxWindow * >(argp1);
36774 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36775 if (!SWIG_IsOK(res2)) {
36776 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36777 }
36778 {
36779 PyThreadState* __tstate = wxPyBeginAllowThreads();
36780 (arg1)->SetToolTip(arg2);
36781 wxPyEndAllowThreads(__tstate);
36782 if (PyErr_Occurred()) SWIG_fail;
36783 }
36784 resultobj = SWIG_Py_Void();
36785 return resultobj;
36786 fail:
36787 return NULL;
36788 }
36789
36790
36791 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36792 PyObject *resultobj = 0;
36793 wxWindow *arg1 = (wxWindow *) 0 ;
36794 wxToolTip *result = 0 ;
36795 void *argp1 = 0 ;
36796 int res1 = 0 ;
36797 PyObject *swig_obj[1] ;
36798
36799 if (!args) SWIG_fail;
36800 swig_obj[0] = args;
36801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36802 if (!SWIG_IsOK(res1)) {
36803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36804 }
36805 arg1 = reinterpret_cast< wxWindow * >(argp1);
36806 {
36807 PyThreadState* __tstate = wxPyBeginAllowThreads();
36808 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36809 wxPyEndAllowThreads(__tstate);
36810 if (PyErr_Occurred()) SWIG_fail;
36811 }
36812 {
36813 resultobj = wxPyMake_wxObject(result, (bool)0);
36814 }
36815 return resultobj;
36816 fail:
36817 return NULL;
36818 }
36819
36820
36821 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36822 PyObject *resultobj = 0;
36823 wxWindow *arg1 = (wxWindow *) 0 ;
36824 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
36825 void *argp1 = 0 ;
36826 int res1 = 0 ;
36827 int res2 = 0 ;
36828 PyObject * obj0 = 0 ;
36829 PyObject * obj1 = 0 ;
36830 char * kwnames[] = {
36831 (char *) "self",(char *) "dropTarget", NULL
36832 };
36833
36834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
36835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36836 if (!SWIG_IsOK(res1)) {
36837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
36838 }
36839 arg1 = reinterpret_cast< wxWindow * >(argp1);
36840 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
36841 if (!SWIG_IsOK(res2)) {
36842 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
36843 }
36844 {
36845 PyThreadState* __tstate = wxPyBeginAllowThreads();
36846 (arg1)->SetDropTarget(arg2);
36847 wxPyEndAllowThreads(__tstate);
36848 if (PyErr_Occurred()) SWIG_fail;
36849 }
36850 resultobj = SWIG_Py_Void();
36851 return resultobj;
36852 fail:
36853 return NULL;
36854 }
36855
36856
36857 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36858 PyObject *resultobj = 0;
36859 wxWindow *arg1 = (wxWindow *) 0 ;
36860 wxPyDropTarget *result = 0 ;
36861 void *argp1 = 0 ;
36862 int res1 = 0 ;
36863 PyObject *swig_obj[1] ;
36864
36865 if (!args) SWIG_fail;
36866 swig_obj[0] = args;
36867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36868 if (!SWIG_IsOK(res1)) {
36869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
36870 }
36871 arg1 = reinterpret_cast< wxWindow * >(argp1);
36872 {
36873 PyThreadState* __tstate = wxPyBeginAllowThreads();
36874 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
36875 wxPyEndAllowThreads(__tstate);
36876 if (PyErr_Occurred()) SWIG_fail;
36877 }
36878 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
36879 return resultobj;
36880 fail:
36881 return NULL;
36882 }
36883
36884
36885 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36886 PyObject *resultobj = 0;
36887 wxWindow *arg1 = (wxWindow *) 0 ;
36888 bool arg2 ;
36889 void *argp1 = 0 ;
36890 int res1 = 0 ;
36891 bool val2 ;
36892 int ecode2 = 0 ;
36893 PyObject * obj0 = 0 ;
36894 PyObject * obj1 = 0 ;
36895 char * kwnames[] = {
36896 (char *) "self",(char *) "accept", NULL
36897 };
36898
36899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
36900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36901 if (!SWIG_IsOK(res1)) {
36902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
36903 }
36904 arg1 = reinterpret_cast< wxWindow * >(argp1);
36905 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36906 if (!SWIG_IsOK(ecode2)) {
36907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
36908 }
36909 arg2 = static_cast< bool >(val2);
36910 {
36911 PyThreadState* __tstate = wxPyBeginAllowThreads();
36912 wxWindow_DragAcceptFiles(arg1,arg2);
36913 wxPyEndAllowThreads(__tstate);
36914 if (PyErr_Occurred()) SWIG_fail;
36915 }
36916 resultobj = SWIG_Py_Void();
36917 return resultobj;
36918 fail:
36919 return NULL;
36920 }
36921
36922
36923 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36924 PyObject *resultobj = 0;
36925 wxWindow *arg1 = (wxWindow *) 0 ;
36926 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
36927 void *argp1 = 0 ;
36928 int res1 = 0 ;
36929 int res2 = 0 ;
36930 PyObject * obj0 = 0 ;
36931 PyObject * obj1 = 0 ;
36932 char * kwnames[] = {
36933 (char *) "self",(char *) "constraints", NULL
36934 };
36935
36936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
36937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36938 if (!SWIG_IsOK(res1)) {
36939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
36940 }
36941 arg1 = reinterpret_cast< wxWindow * >(argp1);
36942 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
36943 if (!SWIG_IsOK(res2)) {
36944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
36945 }
36946 {
36947 PyThreadState* __tstate = wxPyBeginAllowThreads();
36948 (arg1)->SetConstraints(arg2);
36949 wxPyEndAllowThreads(__tstate);
36950 if (PyErr_Occurred()) SWIG_fail;
36951 }
36952 resultobj = SWIG_Py_Void();
36953 return resultobj;
36954 fail:
36955 return NULL;
36956 }
36957
36958
36959 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36960 PyObject *resultobj = 0;
36961 wxWindow *arg1 = (wxWindow *) 0 ;
36962 wxLayoutConstraints *result = 0 ;
36963 void *argp1 = 0 ;
36964 int res1 = 0 ;
36965 PyObject *swig_obj[1] ;
36966
36967 if (!args) SWIG_fail;
36968 swig_obj[0] = args;
36969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36970 if (!SWIG_IsOK(res1)) {
36971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
36972 }
36973 arg1 = reinterpret_cast< wxWindow * >(argp1);
36974 {
36975 PyThreadState* __tstate = wxPyBeginAllowThreads();
36976 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
36977 wxPyEndAllowThreads(__tstate);
36978 if (PyErr_Occurred()) SWIG_fail;
36979 }
36980 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
36981 return resultobj;
36982 fail:
36983 return NULL;
36984 }
36985
36986
36987 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36988 PyObject *resultobj = 0;
36989 wxWindow *arg1 = (wxWindow *) 0 ;
36990 bool arg2 ;
36991 void *argp1 = 0 ;
36992 int res1 = 0 ;
36993 bool val2 ;
36994 int ecode2 = 0 ;
36995 PyObject * obj0 = 0 ;
36996 PyObject * obj1 = 0 ;
36997 char * kwnames[] = {
36998 (char *) "self",(char *) "autoLayout", NULL
36999 };
37000
37001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37003 if (!SWIG_IsOK(res1)) {
37004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37005 }
37006 arg1 = reinterpret_cast< wxWindow * >(argp1);
37007 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37008 if (!SWIG_IsOK(ecode2)) {
37009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37010 }
37011 arg2 = static_cast< bool >(val2);
37012 {
37013 PyThreadState* __tstate = wxPyBeginAllowThreads();
37014 (arg1)->SetAutoLayout(arg2);
37015 wxPyEndAllowThreads(__tstate);
37016 if (PyErr_Occurred()) SWIG_fail;
37017 }
37018 resultobj = SWIG_Py_Void();
37019 return resultobj;
37020 fail:
37021 return NULL;
37022 }
37023
37024
37025 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37026 PyObject *resultobj = 0;
37027 wxWindow *arg1 = (wxWindow *) 0 ;
37028 bool result;
37029 void *argp1 = 0 ;
37030 int res1 = 0 ;
37031 PyObject *swig_obj[1] ;
37032
37033 if (!args) SWIG_fail;
37034 swig_obj[0] = args;
37035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37036 if (!SWIG_IsOK(res1)) {
37037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37038 }
37039 arg1 = reinterpret_cast< wxWindow * >(argp1);
37040 {
37041 PyThreadState* __tstate = wxPyBeginAllowThreads();
37042 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37043 wxPyEndAllowThreads(__tstate);
37044 if (PyErr_Occurred()) SWIG_fail;
37045 }
37046 {
37047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37048 }
37049 return resultobj;
37050 fail:
37051 return NULL;
37052 }
37053
37054
37055 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37056 PyObject *resultobj = 0;
37057 wxWindow *arg1 = (wxWindow *) 0 ;
37058 bool result;
37059 void *argp1 = 0 ;
37060 int res1 = 0 ;
37061 PyObject *swig_obj[1] ;
37062
37063 if (!args) SWIG_fail;
37064 swig_obj[0] = args;
37065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37066 if (!SWIG_IsOK(res1)) {
37067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37068 }
37069 arg1 = reinterpret_cast< wxWindow * >(argp1);
37070 {
37071 PyThreadState* __tstate = wxPyBeginAllowThreads();
37072 result = (bool)(arg1)->Layout();
37073 wxPyEndAllowThreads(__tstate);
37074 if (PyErr_Occurred()) SWIG_fail;
37075 }
37076 {
37077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37078 }
37079 return resultobj;
37080 fail:
37081 return NULL;
37082 }
37083
37084
37085 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37086 PyObject *resultobj = 0;
37087 wxWindow *arg1 = (wxWindow *) 0 ;
37088 wxSizer *arg2 = (wxSizer *) 0 ;
37089 bool arg3 = (bool) true ;
37090 void *argp1 = 0 ;
37091 int res1 = 0 ;
37092 int res2 = 0 ;
37093 bool val3 ;
37094 int ecode3 = 0 ;
37095 PyObject * obj0 = 0 ;
37096 PyObject * obj1 = 0 ;
37097 PyObject * obj2 = 0 ;
37098 char * kwnames[] = {
37099 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37100 };
37101
37102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37104 if (!SWIG_IsOK(res1)) {
37105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37106 }
37107 arg1 = reinterpret_cast< wxWindow * >(argp1);
37108 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37109 if (!SWIG_IsOK(res2)) {
37110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37111 }
37112 if (obj2) {
37113 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37114 if (!SWIG_IsOK(ecode3)) {
37115 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37116 }
37117 arg3 = static_cast< bool >(val3);
37118 }
37119 {
37120 PyThreadState* __tstate = wxPyBeginAllowThreads();
37121 (arg1)->SetSizer(arg2,arg3);
37122 wxPyEndAllowThreads(__tstate);
37123 if (PyErr_Occurred()) SWIG_fail;
37124 }
37125 resultobj = SWIG_Py_Void();
37126 return resultobj;
37127 fail:
37128 return NULL;
37129 }
37130
37131
37132 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37133 PyObject *resultobj = 0;
37134 wxWindow *arg1 = (wxWindow *) 0 ;
37135 wxSizer *arg2 = (wxSizer *) 0 ;
37136 bool arg3 = (bool) true ;
37137 void *argp1 = 0 ;
37138 int res1 = 0 ;
37139 int res2 = 0 ;
37140 bool val3 ;
37141 int ecode3 = 0 ;
37142 PyObject * obj0 = 0 ;
37143 PyObject * obj1 = 0 ;
37144 PyObject * obj2 = 0 ;
37145 char * kwnames[] = {
37146 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37147 };
37148
37149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37151 if (!SWIG_IsOK(res1)) {
37152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37153 }
37154 arg1 = reinterpret_cast< wxWindow * >(argp1);
37155 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37156 if (!SWIG_IsOK(res2)) {
37157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37158 }
37159 if (obj2) {
37160 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37161 if (!SWIG_IsOK(ecode3)) {
37162 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37163 }
37164 arg3 = static_cast< bool >(val3);
37165 }
37166 {
37167 PyThreadState* __tstate = wxPyBeginAllowThreads();
37168 (arg1)->SetSizerAndFit(arg2,arg3);
37169 wxPyEndAllowThreads(__tstate);
37170 if (PyErr_Occurred()) SWIG_fail;
37171 }
37172 resultobj = SWIG_Py_Void();
37173 return resultobj;
37174 fail:
37175 return NULL;
37176 }
37177
37178
37179 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37180 PyObject *resultobj = 0;
37181 wxWindow *arg1 = (wxWindow *) 0 ;
37182 wxSizer *result = 0 ;
37183 void *argp1 = 0 ;
37184 int res1 = 0 ;
37185 PyObject *swig_obj[1] ;
37186
37187 if (!args) SWIG_fail;
37188 swig_obj[0] = args;
37189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37190 if (!SWIG_IsOK(res1)) {
37191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37192 }
37193 arg1 = reinterpret_cast< wxWindow * >(argp1);
37194 {
37195 PyThreadState* __tstate = wxPyBeginAllowThreads();
37196 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37197 wxPyEndAllowThreads(__tstate);
37198 if (PyErr_Occurred()) SWIG_fail;
37199 }
37200 {
37201 resultobj = wxPyMake_wxObject(result, (bool)0);
37202 }
37203 return resultobj;
37204 fail:
37205 return NULL;
37206 }
37207
37208
37209 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37210 PyObject *resultobj = 0;
37211 wxWindow *arg1 = (wxWindow *) 0 ;
37212 wxSizer *arg2 = (wxSizer *) 0 ;
37213 void *argp1 = 0 ;
37214 int res1 = 0 ;
37215 void *argp2 = 0 ;
37216 int res2 = 0 ;
37217 PyObject * obj0 = 0 ;
37218 PyObject * obj1 = 0 ;
37219 char * kwnames[] = {
37220 (char *) "self",(char *) "sizer", NULL
37221 };
37222
37223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",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_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37227 }
37228 arg1 = reinterpret_cast< wxWindow * >(argp1);
37229 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37230 if (!SWIG_IsOK(res2)) {
37231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37232 }
37233 arg2 = reinterpret_cast< wxSizer * >(argp2);
37234 {
37235 PyThreadState* __tstate = wxPyBeginAllowThreads();
37236 (arg1)->SetContainingSizer(arg2);
37237 wxPyEndAllowThreads(__tstate);
37238 if (PyErr_Occurred()) SWIG_fail;
37239 }
37240 resultobj = SWIG_Py_Void();
37241 return resultobj;
37242 fail:
37243 return NULL;
37244 }
37245
37246
37247 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37248 PyObject *resultobj = 0;
37249 wxWindow *arg1 = (wxWindow *) 0 ;
37250 wxSizer *result = 0 ;
37251 void *argp1 = 0 ;
37252 int res1 = 0 ;
37253 PyObject *swig_obj[1] ;
37254
37255 if (!args) SWIG_fail;
37256 swig_obj[0] = args;
37257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37258 if (!SWIG_IsOK(res1)) {
37259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37260 }
37261 arg1 = reinterpret_cast< wxWindow * >(argp1);
37262 {
37263 PyThreadState* __tstate = wxPyBeginAllowThreads();
37264 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37265 wxPyEndAllowThreads(__tstate);
37266 if (PyErr_Occurred()) SWIG_fail;
37267 }
37268 {
37269 resultobj = wxPyMake_wxObject(result, (bool)0);
37270 }
37271 return resultobj;
37272 fail:
37273 return NULL;
37274 }
37275
37276
37277 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37278 PyObject *resultobj = 0;
37279 wxWindow *arg1 = (wxWindow *) 0 ;
37280 void *argp1 = 0 ;
37281 int res1 = 0 ;
37282 PyObject *swig_obj[1] ;
37283
37284 if (!args) SWIG_fail;
37285 swig_obj[0] = args;
37286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37287 if (!SWIG_IsOK(res1)) {
37288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37289 }
37290 arg1 = reinterpret_cast< wxWindow * >(argp1);
37291 {
37292 PyThreadState* __tstate = wxPyBeginAllowThreads();
37293 (arg1)->InheritAttributes();
37294 wxPyEndAllowThreads(__tstate);
37295 if (PyErr_Occurred()) SWIG_fail;
37296 }
37297 resultobj = SWIG_Py_Void();
37298 return resultobj;
37299 fail:
37300 return NULL;
37301 }
37302
37303
37304 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37305 PyObject *resultobj = 0;
37306 wxWindow *arg1 = (wxWindow *) 0 ;
37307 bool result;
37308 void *argp1 = 0 ;
37309 int res1 = 0 ;
37310 PyObject *swig_obj[1] ;
37311
37312 if (!args) SWIG_fail;
37313 swig_obj[0] = args;
37314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37315 if (!SWIG_IsOK(res1)) {
37316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37317 }
37318 arg1 = reinterpret_cast< wxWindow * >(argp1);
37319 {
37320 PyThreadState* __tstate = wxPyBeginAllowThreads();
37321 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37322 wxPyEndAllowThreads(__tstate);
37323 if (PyErr_Occurred()) SWIG_fail;
37324 }
37325 {
37326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37327 }
37328 return resultobj;
37329 fail:
37330 return NULL;
37331 }
37332
37333
37334 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37335 PyObject *obj;
37336 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37337 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37338 return SWIG_Py_Void();
37339 }
37340
37341 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37342 return SWIG_Python_InitShadowInstance(args);
37343 }
37344
37345 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37346 PyObject *resultobj = 0;
37347 long arg1 ;
37348 wxWindow *arg2 = (wxWindow *) NULL ;
37349 wxWindow *result = 0 ;
37350 long val1 ;
37351 int ecode1 = 0 ;
37352 void *argp2 = 0 ;
37353 int res2 = 0 ;
37354 PyObject * obj0 = 0 ;
37355 PyObject * obj1 = 0 ;
37356 char * kwnames[] = {
37357 (char *) "id",(char *) "parent", NULL
37358 };
37359
37360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37361 ecode1 = SWIG_AsVal_long(obj0, &val1);
37362 if (!SWIG_IsOK(ecode1)) {
37363 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37364 }
37365 arg1 = static_cast< long >(val1);
37366 if (obj1) {
37367 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37368 if (!SWIG_IsOK(res2)) {
37369 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37370 }
37371 arg2 = reinterpret_cast< wxWindow * >(argp2);
37372 }
37373 {
37374 if (!wxPyCheckForApp()) SWIG_fail;
37375 PyThreadState* __tstate = wxPyBeginAllowThreads();
37376 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37377 wxPyEndAllowThreads(__tstate);
37378 if (PyErr_Occurred()) SWIG_fail;
37379 }
37380 {
37381 resultobj = wxPyMake_wxObject(result, 0);
37382 }
37383 return resultobj;
37384 fail:
37385 return NULL;
37386 }
37387
37388
37389 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37390 PyObject *resultobj = 0;
37391 wxString *arg1 = 0 ;
37392 wxWindow *arg2 = (wxWindow *) NULL ;
37393 wxWindow *result = 0 ;
37394 bool temp1 = false ;
37395 void *argp2 = 0 ;
37396 int res2 = 0 ;
37397 PyObject * obj0 = 0 ;
37398 PyObject * obj1 = 0 ;
37399 char * kwnames[] = {
37400 (char *) "name",(char *) "parent", NULL
37401 };
37402
37403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37404 {
37405 arg1 = wxString_in_helper(obj0);
37406 if (arg1 == NULL) SWIG_fail;
37407 temp1 = true;
37408 }
37409 if (obj1) {
37410 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37411 if (!SWIG_IsOK(res2)) {
37412 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37413 }
37414 arg2 = reinterpret_cast< wxWindow * >(argp2);
37415 }
37416 {
37417 if (!wxPyCheckForApp()) SWIG_fail;
37418 PyThreadState* __tstate = wxPyBeginAllowThreads();
37419 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37420 wxPyEndAllowThreads(__tstate);
37421 if (PyErr_Occurred()) SWIG_fail;
37422 }
37423 {
37424 resultobj = wxPyMake_wxObject(result, 0);
37425 }
37426 {
37427 if (temp1)
37428 delete arg1;
37429 }
37430 return resultobj;
37431 fail:
37432 {
37433 if (temp1)
37434 delete arg1;
37435 }
37436 return NULL;
37437 }
37438
37439
37440 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37441 PyObject *resultobj = 0;
37442 wxString *arg1 = 0 ;
37443 wxWindow *arg2 = (wxWindow *) NULL ;
37444 wxWindow *result = 0 ;
37445 bool temp1 = false ;
37446 void *argp2 = 0 ;
37447 int res2 = 0 ;
37448 PyObject * obj0 = 0 ;
37449 PyObject * obj1 = 0 ;
37450 char * kwnames[] = {
37451 (char *) "label",(char *) "parent", NULL
37452 };
37453
37454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37455 {
37456 arg1 = wxString_in_helper(obj0);
37457 if (arg1 == NULL) SWIG_fail;
37458 temp1 = true;
37459 }
37460 if (obj1) {
37461 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37462 if (!SWIG_IsOK(res2)) {
37463 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37464 }
37465 arg2 = reinterpret_cast< wxWindow * >(argp2);
37466 }
37467 {
37468 if (!wxPyCheckForApp()) SWIG_fail;
37469 PyThreadState* __tstate = wxPyBeginAllowThreads();
37470 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37471 wxPyEndAllowThreads(__tstate);
37472 if (PyErr_Occurred()) SWIG_fail;
37473 }
37474 {
37475 resultobj = wxPyMake_wxObject(result, 0);
37476 }
37477 {
37478 if (temp1)
37479 delete arg1;
37480 }
37481 return resultobj;
37482 fail:
37483 {
37484 if (temp1)
37485 delete arg1;
37486 }
37487 return NULL;
37488 }
37489
37490
37491 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37492 PyObject *resultobj = 0;
37493 wxWindow *arg1 = (wxWindow *) 0 ;
37494 unsigned long arg2 ;
37495 wxWindow *result = 0 ;
37496 void *argp1 = 0 ;
37497 int res1 = 0 ;
37498 unsigned long val2 ;
37499 int ecode2 = 0 ;
37500 PyObject * obj0 = 0 ;
37501 PyObject * obj1 = 0 ;
37502 char * kwnames[] = {
37503 (char *) "parent",(char *) "_hWnd", NULL
37504 };
37505
37506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37508 if (!SWIG_IsOK(res1)) {
37509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37510 }
37511 arg1 = reinterpret_cast< wxWindow * >(argp1);
37512 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37513 if (!SWIG_IsOK(ecode2)) {
37514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37515 }
37516 arg2 = static_cast< unsigned long >(val2);
37517 {
37518 PyThreadState* __tstate = wxPyBeginAllowThreads();
37519 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37520 wxPyEndAllowThreads(__tstate);
37521 if (PyErr_Occurred()) SWIG_fail;
37522 }
37523 {
37524 resultobj = wxPyMake_wxObject(result, 0);
37525 }
37526 return resultobj;
37527 fail:
37528 return NULL;
37529 }
37530
37531
37532 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37533 PyObject *resultobj = 0;
37534 PyObject *result = 0 ;
37535
37536 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37537 {
37538 PyThreadState* __tstate = wxPyBeginAllowThreads();
37539 result = (PyObject *)GetTopLevelWindows();
37540 wxPyEndAllowThreads(__tstate);
37541 if (PyErr_Occurred()) SWIG_fail;
37542 }
37543 resultobj = result;
37544 return resultobj;
37545 fail:
37546 return NULL;
37547 }
37548
37549
37550 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37551 PyObject *resultobj = 0;
37552 wxValidator *result = 0 ;
37553
37554 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37555 {
37556 PyThreadState* __tstate = wxPyBeginAllowThreads();
37557 result = (wxValidator *)new wxValidator();
37558 wxPyEndAllowThreads(__tstate);
37559 if (PyErr_Occurred()) SWIG_fail;
37560 }
37561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37562 return resultobj;
37563 fail:
37564 return NULL;
37565 }
37566
37567
37568 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37569 PyObject *resultobj = 0;
37570 wxValidator *arg1 = (wxValidator *) 0 ;
37571 wxValidator *result = 0 ;
37572 void *argp1 = 0 ;
37573 int res1 = 0 ;
37574 PyObject *swig_obj[1] ;
37575
37576 if (!args) SWIG_fail;
37577 swig_obj[0] = args;
37578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37579 if (!SWIG_IsOK(res1)) {
37580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37581 }
37582 arg1 = reinterpret_cast< wxValidator * >(argp1);
37583 {
37584 PyThreadState* __tstate = wxPyBeginAllowThreads();
37585 result = (wxValidator *)(arg1)->Clone();
37586 wxPyEndAllowThreads(__tstate);
37587 if (PyErr_Occurred()) SWIG_fail;
37588 }
37589 {
37590 resultobj = wxPyMake_wxObject(result, 0);
37591 }
37592 return resultobj;
37593 fail:
37594 return NULL;
37595 }
37596
37597
37598 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37599 PyObject *resultobj = 0;
37600 wxValidator *arg1 = (wxValidator *) 0 ;
37601 wxWindow *arg2 = (wxWindow *) 0 ;
37602 bool result;
37603 void *argp1 = 0 ;
37604 int res1 = 0 ;
37605 void *argp2 = 0 ;
37606 int res2 = 0 ;
37607 PyObject * obj0 = 0 ;
37608 PyObject * obj1 = 0 ;
37609 char * kwnames[] = {
37610 (char *) "self",(char *) "parent", NULL
37611 };
37612
37613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37615 if (!SWIG_IsOK(res1)) {
37616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37617 }
37618 arg1 = reinterpret_cast< wxValidator * >(argp1);
37619 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37620 if (!SWIG_IsOK(res2)) {
37621 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37622 }
37623 arg2 = reinterpret_cast< wxWindow * >(argp2);
37624 {
37625 PyThreadState* __tstate = wxPyBeginAllowThreads();
37626 result = (bool)(arg1)->Validate(arg2);
37627 wxPyEndAllowThreads(__tstate);
37628 if (PyErr_Occurred()) SWIG_fail;
37629 }
37630 {
37631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37632 }
37633 return resultobj;
37634 fail:
37635 return NULL;
37636 }
37637
37638
37639 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37640 PyObject *resultobj = 0;
37641 wxValidator *arg1 = (wxValidator *) 0 ;
37642 bool result;
37643 void *argp1 = 0 ;
37644 int res1 = 0 ;
37645 PyObject *swig_obj[1] ;
37646
37647 if (!args) SWIG_fail;
37648 swig_obj[0] = args;
37649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37650 if (!SWIG_IsOK(res1)) {
37651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37652 }
37653 arg1 = reinterpret_cast< wxValidator * >(argp1);
37654 {
37655 PyThreadState* __tstate = wxPyBeginAllowThreads();
37656 result = (bool)(arg1)->TransferToWindow();
37657 wxPyEndAllowThreads(__tstate);
37658 if (PyErr_Occurred()) SWIG_fail;
37659 }
37660 {
37661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37662 }
37663 return resultobj;
37664 fail:
37665 return NULL;
37666 }
37667
37668
37669 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37670 PyObject *resultobj = 0;
37671 wxValidator *arg1 = (wxValidator *) 0 ;
37672 bool result;
37673 void *argp1 = 0 ;
37674 int res1 = 0 ;
37675 PyObject *swig_obj[1] ;
37676
37677 if (!args) SWIG_fail;
37678 swig_obj[0] = args;
37679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37680 if (!SWIG_IsOK(res1)) {
37681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37682 }
37683 arg1 = reinterpret_cast< wxValidator * >(argp1);
37684 {
37685 PyThreadState* __tstate = wxPyBeginAllowThreads();
37686 result = (bool)(arg1)->TransferFromWindow();
37687 wxPyEndAllowThreads(__tstate);
37688 if (PyErr_Occurred()) SWIG_fail;
37689 }
37690 {
37691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37692 }
37693 return resultobj;
37694 fail:
37695 return NULL;
37696 }
37697
37698
37699 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37700 PyObject *resultobj = 0;
37701 wxValidator *arg1 = (wxValidator *) 0 ;
37702 wxWindow *result = 0 ;
37703 void *argp1 = 0 ;
37704 int res1 = 0 ;
37705 PyObject *swig_obj[1] ;
37706
37707 if (!args) SWIG_fail;
37708 swig_obj[0] = args;
37709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37710 if (!SWIG_IsOK(res1)) {
37711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37712 }
37713 arg1 = reinterpret_cast< wxValidator * >(argp1);
37714 {
37715 PyThreadState* __tstate = wxPyBeginAllowThreads();
37716 result = (wxWindow *)(arg1)->GetWindow();
37717 wxPyEndAllowThreads(__tstate);
37718 if (PyErr_Occurred()) SWIG_fail;
37719 }
37720 {
37721 resultobj = wxPyMake_wxObject(result, 0);
37722 }
37723 return resultobj;
37724 fail:
37725 return NULL;
37726 }
37727
37728
37729 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37730 PyObject *resultobj = 0;
37731 wxValidator *arg1 = (wxValidator *) 0 ;
37732 wxWindow *arg2 = (wxWindow *) 0 ;
37733 void *argp1 = 0 ;
37734 int res1 = 0 ;
37735 void *argp2 = 0 ;
37736 int res2 = 0 ;
37737 PyObject * obj0 = 0 ;
37738 PyObject * obj1 = 0 ;
37739 char * kwnames[] = {
37740 (char *) "self",(char *) "window", NULL
37741 };
37742
37743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37745 if (!SWIG_IsOK(res1)) {
37746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37747 }
37748 arg1 = reinterpret_cast< wxValidator * >(argp1);
37749 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37750 if (!SWIG_IsOK(res2)) {
37751 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37752 }
37753 arg2 = reinterpret_cast< wxWindow * >(argp2);
37754 {
37755 PyThreadState* __tstate = wxPyBeginAllowThreads();
37756 (arg1)->SetWindow(arg2);
37757 wxPyEndAllowThreads(__tstate);
37758 if (PyErr_Occurred()) SWIG_fail;
37759 }
37760 resultobj = SWIG_Py_Void();
37761 return resultobj;
37762 fail:
37763 return NULL;
37764 }
37765
37766
37767 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37768 PyObject *resultobj = 0;
37769 bool result;
37770
37771 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37772 {
37773 PyThreadState* __tstate = wxPyBeginAllowThreads();
37774 result = (bool)wxValidator::IsSilent();
37775 wxPyEndAllowThreads(__tstate);
37776 if (PyErr_Occurred()) SWIG_fail;
37777 }
37778 {
37779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37780 }
37781 return resultobj;
37782 fail:
37783 return NULL;
37784 }
37785
37786
37787 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37788 PyObject *resultobj = 0;
37789 int arg1 = (int) true ;
37790 int val1 ;
37791 int ecode1 = 0 ;
37792 PyObject * obj0 = 0 ;
37793 char * kwnames[] = {
37794 (char *) "doIt", NULL
37795 };
37796
37797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37798 if (obj0) {
37799 ecode1 = SWIG_AsVal_int(obj0, &val1);
37800 if (!SWIG_IsOK(ecode1)) {
37801 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37802 }
37803 arg1 = static_cast< int >(val1);
37804 }
37805 {
37806 PyThreadState* __tstate = wxPyBeginAllowThreads();
37807 wxValidator::SetBellOnError(arg1);
37808 wxPyEndAllowThreads(__tstate);
37809 if (PyErr_Occurred()) SWIG_fail;
37810 }
37811 resultobj = SWIG_Py_Void();
37812 return resultobj;
37813 fail:
37814 return NULL;
37815 }
37816
37817
37818 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37819 PyObject *obj;
37820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37821 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
37822 return SWIG_Py_Void();
37823 }
37824
37825 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37826 return SWIG_Python_InitShadowInstance(args);
37827 }
37828
37829 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37830 PyObject *resultobj = 0;
37831 wxPyValidator *result = 0 ;
37832
37833 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
37834 {
37835 PyThreadState* __tstate = wxPyBeginAllowThreads();
37836 result = (wxPyValidator *)new wxPyValidator();
37837 wxPyEndAllowThreads(__tstate);
37838 if (PyErr_Occurred()) SWIG_fail;
37839 }
37840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
37841 return resultobj;
37842 fail:
37843 return NULL;
37844 }
37845
37846
37847 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37848 PyObject *resultobj = 0;
37849 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
37850 PyObject *arg2 = (PyObject *) 0 ;
37851 PyObject *arg3 = (PyObject *) 0 ;
37852 int arg4 = (int) true ;
37853 void *argp1 = 0 ;
37854 int res1 = 0 ;
37855 int val4 ;
37856 int ecode4 = 0 ;
37857 PyObject * obj0 = 0 ;
37858 PyObject * obj1 = 0 ;
37859 PyObject * obj2 = 0 ;
37860 PyObject * obj3 = 0 ;
37861 char * kwnames[] = {
37862 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
37863 };
37864
37865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
37867 if (!SWIG_IsOK(res1)) {
37868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
37869 }
37870 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
37871 arg2 = obj1;
37872 arg3 = obj2;
37873 if (obj3) {
37874 ecode4 = SWIG_AsVal_int(obj3, &val4);
37875 if (!SWIG_IsOK(ecode4)) {
37876 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
37877 }
37878 arg4 = static_cast< int >(val4);
37879 }
37880 {
37881 PyThreadState* __tstate = wxPyBeginAllowThreads();
37882 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
37883 wxPyEndAllowThreads(__tstate);
37884 if (PyErr_Occurred()) SWIG_fail;
37885 }
37886 resultobj = SWIG_Py_Void();
37887 return resultobj;
37888 fail:
37889 return NULL;
37890 }
37891
37892
37893 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37894 PyObject *obj;
37895 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37896 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
37897 return SWIG_Py_Void();
37898 }
37899
37900 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37901 return SWIG_Python_InitShadowInstance(args);
37902 }
37903
37904 SWIGINTERN int DefaultValidator_set(PyObject *) {
37905 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
37906 return 1;
37907 }
37908
37909
37910 SWIGINTERN PyObject *DefaultValidator_get(void) {
37911 PyObject *pyobj = 0;
37912
37913 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
37914 return pyobj;
37915 }
37916
37917
37918 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37919 PyObject *resultobj = 0;
37920 wxString const &arg1_defvalue = wxPyEmptyString ;
37921 wxString *arg1 = (wxString *) &arg1_defvalue ;
37922 long arg2 = (long) 0 ;
37923 wxMenu *result = 0 ;
37924 bool temp1 = false ;
37925 long val2 ;
37926 int ecode2 = 0 ;
37927 PyObject * obj0 = 0 ;
37928 PyObject * obj1 = 0 ;
37929 char * kwnames[] = {
37930 (char *) "title",(char *) "style", NULL
37931 };
37932
37933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
37934 if (obj0) {
37935 {
37936 arg1 = wxString_in_helper(obj0);
37937 if (arg1 == NULL) SWIG_fail;
37938 temp1 = true;
37939 }
37940 }
37941 if (obj1) {
37942 ecode2 = SWIG_AsVal_long(obj1, &val2);
37943 if (!SWIG_IsOK(ecode2)) {
37944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
37945 }
37946 arg2 = static_cast< long >(val2);
37947 }
37948 {
37949 if (!wxPyCheckForApp()) SWIG_fail;
37950 PyThreadState* __tstate = wxPyBeginAllowThreads();
37951 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
37952 wxPyEndAllowThreads(__tstate);
37953 if (PyErr_Occurred()) SWIG_fail;
37954 }
37955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
37956 {
37957 if (temp1)
37958 delete arg1;
37959 }
37960 return resultobj;
37961 fail:
37962 {
37963 if (temp1)
37964 delete arg1;
37965 }
37966 return NULL;
37967 }
37968
37969
37970 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37971 PyObject *resultobj = 0;
37972 wxMenu *arg1 = (wxMenu *) 0 ;
37973 int arg2 ;
37974 wxString *arg3 = 0 ;
37975 wxString const &arg4_defvalue = wxPyEmptyString ;
37976 wxString *arg4 = (wxString *) &arg4_defvalue ;
37977 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
37978 wxMenuItem *result = 0 ;
37979 void *argp1 = 0 ;
37980 int res1 = 0 ;
37981 int val2 ;
37982 int ecode2 = 0 ;
37983 bool temp3 = false ;
37984 bool temp4 = false ;
37985 int val5 ;
37986 int ecode5 = 0 ;
37987 PyObject * obj0 = 0 ;
37988 PyObject * obj1 = 0 ;
37989 PyObject * obj2 = 0 ;
37990 PyObject * obj3 = 0 ;
37991 PyObject * obj4 = 0 ;
37992 char * kwnames[] = {
37993 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
37994 };
37995
37996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
37998 if (!SWIG_IsOK(res1)) {
37999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38000 }
38001 arg1 = reinterpret_cast< wxMenu * >(argp1);
38002 ecode2 = SWIG_AsVal_int(obj1, &val2);
38003 if (!SWIG_IsOK(ecode2)) {
38004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38005 }
38006 arg2 = static_cast< int >(val2);
38007 {
38008 arg3 = wxString_in_helper(obj2);
38009 if (arg3 == NULL) SWIG_fail;
38010 temp3 = true;
38011 }
38012 if (obj3) {
38013 {
38014 arg4 = wxString_in_helper(obj3);
38015 if (arg4 == NULL) SWIG_fail;
38016 temp4 = true;
38017 }
38018 }
38019 if (obj4) {
38020 ecode5 = SWIG_AsVal_int(obj4, &val5);
38021 if (!SWIG_IsOK(ecode5)) {
38022 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38023 }
38024 arg5 = static_cast< wxItemKind >(val5);
38025 }
38026 {
38027 PyThreadState* __tstate = wxPyBeginAllowThreads();
38028 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38029 wxPyEndAllowThreads(__tstate);
38030 if (PyErr_Occurred()) SWIG_fail;
38031 }
38032 {
38033 resultobj = wxPyMake_wxObject(result, (bool)0);
38034 }
38035 {
38036 if (temp3)
38037 delete arg3;
38038 }
38039 {
38040 if (temp4)
38041 delete arg4;
38042 }
38043 return resultobj;
38044 fail:
38045 {
38046 if (temp3)
38047 delete arg3;
38048 }
38049 {
38050 if (temp4)
38051 delete arg4;
38052 }
38053 return NULL;
38054 }
38055
38056
38057 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38058 PyObject *resultobj = 0;
38059 wxMenu *arg1 = (wxMenu *) 0 ;
38060 wxMenuItem *result = 0 ;
38061 void *argp1 = 0 ;
38062 int res1 = 0 ;
38063 PyObject *swig_obj[1] ;
38064
38065 if (!args) SWIG_fail;
38066 swig_obj[0] = args;
38067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38068 if (!SWIG_IsOK(res1)) {
38069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38070 }
38071 arg1 = reinterpret_cast< wxMenu * >(argp1);
38072 {
38073 PyThreadState* __tstate = wxPyBeginAllowThreads();
38074 result = (wxMenuItem *)(arg1)->AppendSeparator();
38075 wxPyEndAllowThreads(__tstate);
38076 if (PyErr_Occurred()) SWIG_fail;
38077 }
38078 {
38079 resultobj = wxPyMake_wxObject(result, (bool)0);
38080 }
38081 return resultobj;
38082 fail:
38083 return NULL;
38084 }
38085
38086
38087 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38088 PyObject *resultobj = 0;
38089 wxMenu *arg1 = (wxMenu *) 0 ;
38090 int arg2 ;
38091 wxString *arg3 = 0 ;
38092 wxString const &arg4_defvalue = wxPyEmptyString ;
38093 wxString *arg4 = (wxString *) &arg4_defvalue ;
38094 wxMenuItem *result = 0 ;
38095 void *argp1 = 0 ;
38096 int res1 = 0 ;
38097 int val2 ;
38098 int ecode2 = 0 ;
38099 bool temp3 = false ;
38100 bool temp4 = false ;
38101 PyObject * obj0 = 0 ;
38102 PyObject * obj1 = 0 ;
38103 PyObject * obj2 = 0 ;
38104 PyObject * obj3 = 0 ;
38105 char * kwnames[] = {
38106 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38107 };
38108
38109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38111 if (!SWIG_IsOK(res1)) {
38112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38113 }
38114 arg1 = reinterpret_cast< wxMenu * >(argp1);
38115 ecode2 = SWIG_AsVal_int(obj1, &val2);
38116 if (!SWIG_IsOK(ecode2)) {
38117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38118 }
38119 arg2 = static_cast< int >(val2);
38120 {
38121 arg3 = wxString_in_helper(obj2);
38122 if (arg3 == NULL) SWIG_fail;
38123 temp3 = true;
38124 }
38125 if (obj3) {
38126 {
38127 arg4 = wxString_in_helper(obj3);
38128 if (arg4 == NULL) SWIG_fail;
38129 temp4 = true;
38130 }
38131 }
38132 {
38133 PyThreadState* __tstate = wxPyBeginAllowThreads();
38134 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38135 wxPyEndAllowThreads(__tstate);
38136 if (PyErr_Occurred()) SWIG_fail;
38137 }
38138 {
38139 resultobj = wxPyMake_wxObject(result, (bool)0);
38140 }
38141 {
38142 if (temp3)
38143 delete arg3;
38144 }
38145 {
38146 if (temp4)
38147 delete arg4;
38148 }
38149 return resultobj;
38150 fail:
38151 {
38152 if (temp3)
38153 delete arg3;
38154 }
38155 {
38156 if (temp4)
38157 delete arg4;
38158 }
38159 return NULL;
38160 }
38161
38162
38163 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38164 PyObject *resultobj = 0;
38165 wxMenu *arg1 = (wxMenu *) 0 ;
38166 int arg2 ;
38167 wxString *arg3 = 0 ;
38168 wxString const &arg4_defvalue = wxPyEmptyString ;
38169 wxString *arg4 = (wxString *) &arg4_defvalue ;
38170 wxMenuItem *result = 0 ;
38171 void *argp1 = 0 ;
38172 int res1 = 0 ;
38173 int val2 ;
38174 int ecode2 = 0 ;
38175 bool temp3 = false ;
38176 bool temp4 = false ;
38177 PyObject * obj0 = 0 ;
38178 PyObject * obj1 = 0 ;
38179 PyObject * obj2 = 0 ;
38180 PyObject * obj3 = 0 ;
38181 char * kwnames[] = {
38182 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38183 };
38184
38185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38187 if (!SWIG_IsOK(res1)) {
38188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38189 }
38190 arg1 = reinterpret_cast< wxMenu * >(argp1);
38191 ecode2 = SWIG_AsVal_int(obj1, &val2);
38192 if (!SWIG_IsOK(ecode2)) {
38193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38194 }
38195 arg2 = static_cast< int >(val2);
38196 {
38197 arg3 = wxString_in_helper(obj2);
38198 if (arg3 == NULL) SWIG_fail;
38199 temp3 = true;
38200 }
38201 if (obj3) {
38202 {
38203 arg4 = wxString_in_helper(obj3);
38204 if (arg4 == NULL) SWIG_fail;
38205 temp4 = true;
38206 }
38207 }
38208 {
38209 PyThreadState* __tstate = wxPyBeginAllowThreads();
38210 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38211 wxPyEndAllowThreads(__tstate);
38212 if (PyErr_Occurred()) SWIG_fail;
38213 }
38214 {
38215 resultobj = wxPyMake_wxObject(result, (bool)0);
38216 }
38217 {
38218 if (temp3)
38219 delete arg3;
38220 }
38221 {
38222 if (temp4)
38223 delete arg4;
38224 }
38225 return resultobj;
38226 fail:
38227 {
38228 if (temp3)
38229 delete arg3;
38230 }
38231 {
38232 if (temp4)
38233 delete arg4;
38234 }
38235 return NULL;
38236 }
38237
38238
38239 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38240 PyObject *resultobj = 0;
38241 wxMenu *arg1 = (wxMenu *) 0 ;
38242 int arg2 ;
38243 wxString *arg3 = 0 ;
38244 wxMenu *arg4 = (wxMenu *) 0 ;
38245 wxString const &arg5_defvalue = wxPyEmptyString ;
38246 wxString *arg5 = (wxString *) &arg5_defvalue ;
38247 wxMenuItem *result = 0 ;
38248 void *argp1 = 0 ;
38249 int res1 = 0 ;
38250 int val2 ;
38251 int ecode2 = 0 ;
38252 bool temp3 = false ;
38253 void *argp4 = 0 ;
38254 int res4 = 0 ;
38255 bool temp5 = false ;
38256 PyObject * obj0 = 0 ;
38257 PyObject * obj1 = 0 ;
38258 PyObject * obj2 = 0 ;
38259 PyObject * obj3 = 0 ;
38260 PyObject * obj4 = 0 ;
38261 char * kwnames[] = {
38262 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38263 };
38264
38265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38267 if (!SWIG_IsOK(res1)) {
38268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38269 }
38270 arg1 = reinterpret_cast< wxMenu * >(argp1);
38271 ecode2 = SWIG_AsVal_int(obj1, &val2);
38272 if (!SWIG_IsOK(ecode2)) {
38273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38274 }
38275 arg2 = static_cast< int >(val2);
38276 {
38277 arg3 = wxString_in_helper(obj2);
38278 if (arg3 == NULL) SWIG_fail;
38279 temp3 = true;
38280 }
38281 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38282 if (!SWIG_IsOK(res4)) {
38283 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38284 }
38285 arg4 = reinterpret_cast< wxMenu * >(argp4);
38286 if (obj4) {
38287 {
38288 arg5 = wxString_in_helper(obj4);
38289 if (arg5 == NULL) SWIG_fail;
38290 temp5 = true;
38291 }
38292 }
38293 {
38294 PyThreadState* __tstate = wxPyBeginAllowThreads();
38295 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38296 wxPyEndAllowThreads(__tstate);
38297 if (PyErr_Occurred()) SWIG_fail;
38298 }
38299 {
38300 resultobj = wxPyMake_wxObject(result, (bool)0);
38301 }
38302 {
38303 if (temp3)
38304 delete arg3;
38305 }
38306 {
38307 if (temp5)
38308 delete arg5;
38309 }
38310 return resultobj;
38311 fail:
38312 {
38313 if (temp3)
38314 delete arg3;
38315 }
38316 {
38317 if (temp5)
38318 delete arg5;
38319 }
38320 return NULL;
38321 }
38322
38323
38324 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38325 PyObject *resultobj = 0;
38326 wxMenu *arg1 = (wxMenu *) 0 ;
38327 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38328 wxMenuItem *result = 0 ;
38329 void *argp1 = 0 ;
38330 int res1 = 0 ;
38331 int res2 = 0 ;
38332 PyObject * obj0 = 0 ;
38333 PyObject * obj1 = 0 ;
38334 char * kwnames[] = {
38335 (char *) "self",(char *) "item", NULL
38336 };
38337
38338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38340 if (!SWIG_IsOK(res1)) {
38341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38342 }
38343 arg1 = reinterpret_cast< wxMenu * >(argp1);
38344 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38345 if (!SWIG_IsOK(res2)) {
38346 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38347 }
38348 {
38349 PyThreadState* __tstate = wxPyBeginAllowThreads();
38350 result = (wxMenuItem *)(arg1)->Append(arg2);
38351 wxPyEndAllowThreads(__tstate);
38352 if (PyErr_Occurred()) SWIG_fail;
38353 }
38354 {
38355 resultobj = wxPyMake_wxObject(result, (bool)0);
38356 }
38357 return resultobj;
38358 fail:
38359 return NULL;
38360 }
38361
38362
38363 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38364 PyObject *resultobj = 0;
38365 wxMenu *arg1 = (wxMenu *) 0 ;
38366 size_t arg2 ;
38367 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38368 wxMenuItem *result = 0 ;
38369 void *argp1 = 0 ;
38370 int res1 = 0 ;
38371 size_t val2 ;
38372 int ecode2 = 0 ;
38373 int res3 = 0 ;
38374 PyObject * obj0 = 0 ;
38375 PyObject * obj1 = 0 ;
38376 PyObject * obj2 = 0 ;
38377 char * kwnames[] = {
38378 (char *) "self",(char *) "pos",(char *) "item", NULL
38379 };
38380
38381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38383 if (!SWIG_IsOK(res1)) {
38384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38385 }
38386 arg1 = reinterpret_cast< wxMenu * >(argp1);
38387 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38388 if (!SWIG_IsOK(ecode2)) {
38389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38390 }
38391 arg2 = static_cast< size_t >(val2);
38392 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38393 if (!SWIG_IsOK(res3)) {
38394 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38395 }
38396 {
38397 PyThreadState* __tstate = wxPyBeginAllowThreads();
38398 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38399 wxPyEndAllowThreads(__tstate);
38400 if (PyErr_Occurred()) SWIG_fail;
38401 }
38402 {
38403 resultobj = wxPyMake_wxObject(result, (bool)0);
38404 }
38405 return resultobj;
38406 fail:
38407 return NULL;
38408 }
38409
38410
38411 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38412 PyObject *resultobj = 0;
38413 wxMenu *arg1 = (wxMenu *) 0 ;
38414 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38415 wxMenuItem *result = 0 ;
38416 void *argp1 = 0 ;
38417 int res1 = 0 ;
38418 int res2 = 0 ;
38419 PyObject * obj0 = 0 ;
38420 PyObject * obj1 = 0 ;
38421 char * kwnames[] = {
38422 (char *) "self",(char *) "item", NULL
38423 };
38424
38425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38427 if (!SWIG_IsOK(res1)) {
38428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38429 }
38430 arg1 = reinterpret_cast< wxMenu * >(argp1);
38431 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38432 if (!SWIG_IsOK(res2)) {
38433 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38434 }
38435 {
38436 PyThreadState* __tstate = wxPyBeginAllowThreads();
38437 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38438 wxPyEndAllowThreads(__tstate);
38439 if (PyErr_Occurred()) SWIG_fail;
38440 }
38441 {
38442 resultobj = wxPyMake_wxObject(result, (bool)0);
38443 }
38444 return resultobj;
38445 fail:
38446 return NULL;
38447 }
38448
38449
38450 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38451 PyObject *resultobj = 0;
38452 wxMenu *arg1 = (wxMenu *) 0 ;
38453 void *argp1 = 0 ;
38454 int res1 = 0 ;
38455 PyObject *swig_obj[1] ;
38456
38457 if (!args) SWIG_fail;
38458 swig_obj[0] = args;
38459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38460 if (!SWIG_IsOK(res1)) {
38461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38462 }
38463 arg1 = reinterpret_cast< wxMenu * >(argp1);
38464 {
38465 PyThreadState* __tstate = wxPyBeginAllowThreads();
38466 (arg1)->Break();
38467 wxPyEndAllowThreads(__tstate);
38468 if (PyErr_Occurred()) SWIG_fail;
38469 }
38470 resultobj = SWIG_Py_Void();
38471 return resultobj;
38472 fail:
38473 return NULL;
38474 }
38475
38476
38477 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38478 PyObject *resultobj = 0;
38479 wxMenu *arg1 = (wxMenu *) 0 ;
38480 size_t arg2 ;
38481 int arg3 ;
38482 wxString *arg4 = 0 ;
38483 wxString const &arg5_defvalue = wxPyEmptyString ;
38484 wxString *arg5 = (wxString *) &arg5_defvalue ;
38485 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38486 wxMenuItem *result = 0 ;
38487 void *argp1 = 0 ;
38488 int res1 = 0 ;
38489 size_t val2 ;
38490 int ecode2 = 0 ;
38491 int val3 ;
38492 int ecode3 = 0 ;
38493 bool temp4 = false ;
38494 bool temp5 = false ;
38495 int val6 ;
38496 int ecode6 = 0 ;
38497 PyObject * obj0 = 0 ;
38498 PyObject * obj1 = 0 ;
38499 PyObject * obj2 = 0 ;
38500 PyObject * obj3 = 0 ;
38501 PyObject * obj4 = 0 ;
38502 PyObject * obj5 = 0 ;
38503 char * kwnames[] = {
38504 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38505 };
38506
38507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38509 if (!SWIG_IsOK(res1)) {
38510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38511 }
38512 arg1 = reinterpret_cast< wxMenu * >(argp1);
38513 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38514 if (!SWIG_IsOK(ecode2)) {
38515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38516 }
38517 arg2 = static_cast< size_t >(val2);
38518 ecode3 = SWIG_AsVal_int(obj2, &val3);
38519 if (!SWIG_IsOK(ecode3)) {
38520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38521 }
38522 arg3 = static_cast< int >(val3);
38523 {
38524 arg4 = wxString_in_helper(obj3);
38525 if (arg4 == NULL) SWIG_fail;
38526 temp4 = true;
38527 }
38528 if (obj4) {
38529 {
38530 arg5 = wxString_in_helper(obj4);
38531 if (arg5 == NULL) SWIG_fail;
38532 temp5 = true;
38533 }
38534 }
38535 if (obj5) {
38536 ecode6 = SWIG_AsVal_int(obj5, &val6);
38537 if (!SWIG_IsOK(ecode6)) {
38538 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38539 }
38540 arg6 = static_cast< wxItemKind >(val6);
38541 }
38542 {
38543 PyThreadState* __tstate = wxPyBeginAllowThreads();
38544 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38545 wxPyEndAllowThreads(__tstate);
38546 if (PyErr_Occurred()) SWIG_fail;
38547 }
38548 {
38549 resultobj = wxPyMake_wxObject(result, (bool)0);
38550 }
38551 {
38552 if (temp4)
38553 delete arg4;
38554 }
38555 {
38556 if (temp5)
38557 delete arg5;
38558 }
38559 return resultobj;
38560 fail:
38561 {
38562 if (temp4)
38563 delete arg4;
38564 }
38565 {
38566 if (temp5)
38567 delete arg5;
38568 }
38569 return NULL;
38570 }
38571
38572
38573 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38574 PyObject *resultobj = 0;
38575 wxMenu *arg1 = (wxMenu *) 0 ;
38576 size_t arg2 ;
38577 wxMenuItem *result = 0 ;
38578 void *argp1 = 0 ;
38579 int res1 = 0 ;
38580 size_t val2 ;
38581 int ecode2 = 0 ;
38582 PyObject * obj0 = 0 ;
38583 PyObject * obj1 = 0 ;
38584 char * kwnames[] = {
38585 (char *) "self",(char *) "pos", NULL
38586 };
38587
38588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38590 if (!SWIG_IsOK(res1)) {
38591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38592 }
38593 arg1 = reinterpret_cast< wxMenu * >(argp1);
38594 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38595 if (!SWIG_IsOK(ecode2)) {
38596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38597 }
38598 arg2 = static_cast< size_t >(val2);
38599 {
38600 PyThreadState* __tstate = wxPyBeginAllowThreads();
38601 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38602 wxPyEndAllowThreads(__tstate);
38603 if (PyErr_Occurred()) SWIG_fail;
38604 }
38605 {
38606 resultobj = wxPyMake_wxObject(result, (bool)0);
38607 }
38608 return resultobj;
38609 fail:
38610 return NULL;
38611 }
38612
38613
38614 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38615 PyObject *resultobj = 0;
38616 wxMenu *arg1 = (wxMenu *) 0 ;
38617 size_t arg2 ;
38618 int arg3 ;
38619 wxString *arg4 = 0 ;
38620 wxString const &arg5_defvalue = wxPyEmptyString ;
38621 wxString *arg5 = (wxString *) &arg5_defvalue ;
38622 wxMenuItem *result = 0 ;
38623 void *argp1 = 0 ;
38624 int res1 = 0 ;
38625 size_t val2 ;
38626 int ecode2 = 0 ;
38627 int val3 ;
38628 int ecode3 = 0 ;
38629 bool temp4 = false ;
38630 bool temp5 = false ;
38631 PyObject * obj0 = 0 ;
38632 PyObject * obj1 = 0 ;
38633 PyObject * obj2 = 0 ;
38634 PyObject * obj3 = 0 ;
38635 PyObject * obj4 = 0 ;
38636 char * kwnames[] = {
38637 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38638 };
38639
38640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38642 if (!SWIG_IsOK(res1)) {
38643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38644 }
38645 arg1 = reinterpret_cast< wxMenu * >(argp1);
38646 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38647 if (!SWIG_IsOK(ecode2)) {
38648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38649 }
38650 arg2 = static_cast< size_t >(val2);
38651 ecode3 = SWIG_AsVal_int(obj2, &val3);
38652 if (!SWIG_IsOK(ecode3)) {
38653 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38654 }
38655 arg3 = static_cast< int >(val3);
38656 {
38657 arg4 = wxString_in_helper(obj3);
38658 if (arg4 == NULL) SWIG_fail;
38659 temp4 = true;
38660 }
38661 if (obj4) {
38662 {
38663 arg5 = wxString_in_helper(obj4);
38664 if (arg5 == NULL) SWIG_fail;
38665 temp5 = true;
38666 }
38667 }
38668 {
38669 PyThreadState* __tstate = wxPyBeginAllowThreads();
38670 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38671 wxPyEndAllowThreads(__tstate);
38672 if (PyErr_Occurred()) SWIG_fail;
38673 }
38674 {
38675 resultobj = wxPyMake_wxObject(result, (bool)0);
38676 }
38677 {
38678 if (temp4)
38679 delete arg4;
38680 }
38681 {
38682 if (temp5)
38683 delete arg5;
38684 }
38685 return resultobj;
38686 fail:
38687 {
38688 if (temp4)
38689 delete arg4;
38690 }
38691 {
38692 if (temp5)
38693 delete arg5;
38694 }
38695 return NULL;
38696 }
38697
38698
38699 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38700 PyObject *resultobj = 0;
38701 wxMenu *arg1 = (wxMenu *) 0 ;
38702 size_t arg2 ;
38703 int arg3 ;
38704 wxString *arg4 = 0 ;
38705 wxString const &arg5_defvalue = wxPyEmptyString ;
38706 wxString *arg5 = (wxString *) &arg5_defvalue ;
38707 wxMenuItem *result = 0 ;
38708 void *argp1 = 0 ;
38709 int res1 = 0 ;
38710 size_t val2 ;
38711 int ecode2 = 0 ;
38712 int val3 ;
38713 int ecode3 = 0 ;
38714 bool temp4 = false ;
38715 bool temp5 = false ;
38716 PyObject * obj0 = 0 ;
38717 PyObject * obj1 = 0 ;
38718 PyObject * obj2 = 0 ;
38719 PyObject * obj3 = 0 ;
38720 PyObject * obj4 = 0 ;
38721 char * kwnames[] = {
38722 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38723 };
38724
38725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38727 if (!SWIG_IsOK(res1)) {
38728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38729 }
38730 arg1 = reinterpret_cast< wxMenu * >(argp1);
38731 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38732 if (!SWIG_IsOK(ecode2)) {
38733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38734 }
38735 arg2 = static_cast< size_t >(val2);
38736 ecode3 = SWIG_AsVal_int(obj2, &val3);
38737 if (!SWIG_IsOK(ecode3)) {
38738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
38739 }
38740 arg3 = static_cast< int >(val3);
38741 {
38742 arg4 = wxString_in_helper(obj3);
38743 if (arg4 == NULL) SWIG_fail;
38744 temp4 = true;
38745 }
38746 if (obj4) {
38747 {
38748 arg5 = wxString_in_helper(obj4);
38749 if (arg5 == NULL) SWIG_fail;
38750 temp5 = true;
38751 }
38752 }
38753 {
38754 PyThreadState* __tstate = wxPyBeginAllowThreads();
38755 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38756 wxPyEndAllowThreads(__tstate);
38757 if (PyErr_Occurred()) SWIG_fail;
38758 }
38759 {
38760 resultobj = wxPyMake_wxObject(result, (bool)0);
38761 }
38762 {
38763 if (temp4)
38764 delete arg4;
38765 }
38766 {
38767 if (temp5)
38768 delete arg5;
38769 }
38770 return resultobj;
38771 fail:
38772 {
38773 if (temp4)
38774 delete arg4;
38775 }
38776 {
38777 if (temp5)
38778 delete arg5;
38779 }
38780 return NULL;
38781 }
38782
38783
38784 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38785 PyObject *resultobj = 0;
38786 wxMenu *arg1 = (wxMenu *) 0 ;
38787 size_t arg2 ;
38788 int arg3 ;
38789 wxString *arg4 = 0 ;
38790 wxMenu *arg5 = (wxMenu *) 0 ;
38791 wxString const &arg6_defvalue = wxPyEmptyString ;
38792 wxString *arg6 = (wxString *) &arg6_defvalue ;
38793 wxMenuItem *result = 0 ;
38794 void *argp1 = 0 ;
38795 int res1 = 0 ;
38796 size_t val2 ;
38797 int ecode2 = 0 ;
38798 int val3 ;
38799 int ecode3 = 0 ;
38800 bool temp4 = false ;
38801 void *argp5 = 0 ;
38802 int res5 = 0 ;
38803 bool temp6 = false ;
38804 PyObject * obj0 = 0 ;
38805 PyObject * obj1 = 0 ;
38806 PyObject * obj2 = 0 ;
38807 PyObject * obj3 = 0 ;
38808 PyObject * obj4 = 0 ;
38809 PyObject * obj5 = 0 ;
38810 char * kwnames[] = {
38811 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38812 };
38813
38814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38816 if (!SWIG_IsOK(res1)) {
38817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38818 }
38819 arg1 = reinterpret_cast< wxMenu * >(argp1);
38820 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38821 if (!SWIG_IsOK(ecode2)) {
38822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
38823 }
38824 arg2 = static_cast< size_t >(val2);
38825 ecode3 = SWIG_AsVal_int(obj2, &val3);
38826 if (!SWIG_IsOK(ecode3)) {
38827 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
38828 }
38829 arg3 = static_cast< int >(val3);
38830 {
38831 arg4 = wxString_in_helper(obj3);
38832 if (arg4 == NULL) SWIG_fail;
38833 temp4 = true;
38834 }
38835 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
38836 if (!SWIG_IsOK(res5)) {
38837 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
38838 }
38839 arg5 = reinterpret_cast< wxMenu * >(argp5);
38840 if (obj5) {
38841 {
38842 arg6 = wxString_in_helper(obj5);
38843 if (arg6 == NULL) SWIG_fail;
38844 temp6 = true;
38845 }
38846 }
38847 {
38848 PyThreadState* __tstate = wxPyBeginAllowThreads();
38849 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
38850 wxPyEndAllowThreads(__tstate);
38851 if (PyErr_Occurred()) SWIG_fail;
38852 }
38853 {
38854 resultobj = wxPyMake_wxObject(result, (bool)0);
38855 }
38856 {
38857 if (temp4)
38858 delete arg4;
38859 }
38860 {
38861 if (temp6)
38862 delete arg6;
38863 }
38864 return resultobj;
38865 fail:
38866 {
38867 if (temp4)
38868 delete arg4;
38869 }
38870 {
38871 if (temp6)
38872 delete arg6;
38873 }
38874 return NULL;
38875 }
38876
38877
38878 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38879 PyObject *resultobj = 0;
38880 wxMenu *arg1 = (wxMenu *) 0 ;
38881 int arg2 ;
38882 wxString *arg3 = 0 ;
38883 wxString const &arg4_defvalue = wxPyEmptyString ;
38884 wxString *arg4 = (wxString *) &arg4_defvalue ;
38885 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38886 wxMenuItem *result = 0 ;
38887 void *argp1 = 0 ;
38888 int res1 = 0 ;
38889 int val2 ;
38890 int ecode2 = 0 ;
38891 bool temp3 = false ;
38892 bool temp4 = false ;
38893 int val5 ;
38894 int ecode5 = 0 ;
38895 PyObject * obj0 = 0 ;
38896 PyObject * obj1 = 0 ;
38897 PyObject * obj2 = 0 ;
38898 PyObject * obj3 = 0 ;
38899 PyObject * obj4 = 0 ;
38900 char * kwnames[] = {
38901 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38902 };
38903
38904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38906 if (!SWIG_IsOK(res1)) {
38907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
38908 }
38909 arg1 = reinterpret_cast< wxMenu * >(argp1);
38910 ecode2 = SWIG_AsVal_int(obj1, &val2);
38911 if (!SWIG_IsOK(ecode2)) {
38912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
38913 }
38914 arg2 = static_cast< int >(val2);
38915 {
38916 arg3 = wxString_in_helper(obj2);
38917 if (arg3 == NULL) SWIG_fail;
38918 temp3 = true;
38919 }
38920 if (obj3) {
38921 {
38922 arg4 = wxString_in_helper(obj3);
38923 if (arg4 == NULL) SWIG_fail;
38924 temp4 = true;
38925 }
38926 }
38927 if (obj4) {
38928 ecode5 = SWIG_AsVal_int(obj4, &val5);
38929 if (!SWIG_IsOK(ecode5)) {
38930 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
38931 }
38932 arg5 = static_cast< wxItemKind >(val5);
38933 }
38934 {
38935 PyThreadState* __tstate = wxPyBeginAllowThreads();
38936 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38937 wxPyEndAllowThreads(__tstate);
38938 if (PyErr_Occurred()) SWIG_fail;
38939 }
38940 {
38941 resultobj = wxPyMake_wxObject(result, (bool)0);
38942 }
38943 {
38944 if (temp3)
38945 delete arg3;
38946 }
38947 {
38948 if (temp4)
38949 delete arg4;
38950 }
38951 return resultobj;
38952 fail:
38953 {
38954 if (temp3)
38955 delete arg3;
38956 }
38957 {
38958 if (temp4)
38959 delete arg4;
38960 }
38961 return NULL;
38962 }
38963
38964
38965 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38966 PyObject *resultobj = 0;
38967 wxMenu *arg1 = (wxMenu *) 0 ;
38968 wxMenuItem *result = 0 ;
38969 void *argp1 = 0 ;
38970 int res1 = 0 ;
38971 PyObject *swig_obj[1] ;
38972
38973 if (!args) SWIG_fail;
38974 swig_obj[0] = args;
38975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38976 if (!SWIG_IsOK(res1)) {
38977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38978 }
38979 arg1 = reinterpret_cast< wxMenu * >(argp1);
38980 {
38981 PyThreadState* __tstate = wxPyBeginAllowThreads();
38982 result = (wxMenuItem *)(arg1)->PrependSeparator();
38983 wxPyEndAllowThreads(__tstate);
38984 if (PyErr_Occurred()) SWIG_fail;
38985 }
38986 {
38987 resultobj = wxPyMake_wxObject(result, (bool)0);
38988 }
38989 return resultobj;
38990 fail:
38991 return NULL;
38992 }
38993
38994
38995 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38996 PyObject *resultobj = 0;
38997 wxMenu *arg1 = (wxMenu *) 0 ;
38998 int arg2 ;
38999 wxString *arg3 = 0 ;
39000 wxString const &arg4_defvalue = wxPyEmptyString ;
39001 wxString *arg4 = (wxString *) &arg4_defvalue ;
39002 wxMenuItem *result = 0 ;
39003 void *argp1 = 0 ;
39004 int res1 = 0 ;
39005 int val2 ;
39006 int ecode2 = 0 ;
39007 bool temp3 = false ;
39008 bool temp4 = false ;
39009 PyObject * obj0 = 0 ;
39010 PyObject * obj1 = 0 ;
39011 PyObject * obj2 = 0 ;
39012 PyObject * obj3 = 0 ;
39013 char * kwnames[] = {
39014 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39015 };
39016
39017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39019 if (!SWIG_IsOK(res1)) {
39020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39021 }
39022 arg1 = reinterpret_cast< wxMenu * >(argp1);
39023 ecode2 = SWIG_AsVal_int(obj1, &val2);
39024 if (!SWIG_IsOK(ecode2)) {
39025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39026 }
39027 arg2 = static_cast< int >(val2);
39028 {
39029 arg3 = wxString_in_helper(obj2);
39030 if (arg3 == NULL) SWIG_fail;
39031 temp3 = true;
39032 }
39033 if (obj3) {
39034 {
39035 arg4 = wxString_in_helper(obj3);
39036 if (arg4 == NULL) SWIG_fail;
39037 temp4 = true;
39038 }
39039 }
39040 {
39041 PyThreadState* __tstate = wxPyBeginAllowThreads();
39042 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39043 wxPyEndAllowThreads(__tstate);
39044 if (PyErr_Occurred()) SWIG_fail;
39045 }
39046 {
39047 resultobj = wxPyMake_wxObject(result, (bool)0);
39048 }
39049 {
39050 if (temp3)
39051 delete arg3;
39052 }
39053 {
39054 if (temp4)
39055 delete arg4;
39056 }
39057 return resultobj;
39058 fail:
39059 {
39060 if (temp3)
39061 delete arg3;
39062 }
39063 {
39064 if (temp4)
39065 delete arg4;
39066 }
39067 return NULL;
39068 }
39069
39070
39071 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39072 PyObject *resultobj = 0;
39073 wxMenu *arg1 = (wxMenu *) 0 ;
39074 int arg2 ;
39075 wxString *arg3 = 0 ;
39076 wxString const &arg4_defvalue = wxPyEmptyString ;
39077 wxString *arg4 = (wxString *) &arg4_defvalue ;
39078 wxMenuItem *result = 0 ;
39079 void *argp1 = 0 ;
39080 int res1 = 0 ;
39081 int val2 ;
39082 int ecode2 = 0 ;
39083 bool temp3 = false ;
39084 bool temp4 = false ;
39085 PyObject * obj0 = 0 ;
39086 PyObject * obj1 = 0 ;
39087 PyObject * obj2 = 0 ;
39088 PyObject * obj3 = 0 ;
39089 char * kwnames[] = {
39090 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39091 };
39092
39093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39095 if (!SWIG_IsOK(res1)) {
39096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39097 }
39098 arg1 = reinterpret_cast< wxMenu * >(argp1);
39099 ecode2 = SWIG_AsVal_int(obj1, &val2);
39100 if (!SWIG_IsOK(ecode2)) {
39101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39102 }
39103 arg2 = static_cast< int >(val2);
39104 {
39105 arg3 = wxString_in_helper(obj2);
39106 if (arg3 == NULL) SWIG_fail;
39107 temp3 = true;
39108 }
39109 if (obj3) {
39110 {
39111 arg4 = wxString_in_helper(obj3);
39112 if (arg4 == NULL) SWIG_fail;
39113 temp4 = true;
39114 }
39115 }
39116 {
39117 PyThreadState* __tstate = wxPyBeginAllowThreads();
39118 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39119 wxPyEndAllowThreads(__tstate);
39120 if (PyErr_Occurred()) SWIG_fail;
39121 }
39122 {
39123 resultobj = wxPyMake_wxObject(result, (bool)0);
39124 }
39125 {
39126 if (temp3)
39127 delete arg3;
39128 }
39129 {
39130 if (temp4)
39131 delete arg4;
39132 }
39133 return resultobj;
39134 fail:
39135 {
39136 if (temp3)
39137 delete arg3;
39138 }
39139 {
39140 if (temp4)
39141 delete arg4;
39142 }
39143 return NULL;
39144 }
39145
39146
39147 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39148 PyObject *resultobj = 0;
39149 wxMenu *arg1 = (wxMenu *) 0 ;
39150 int arg2 ;
39151 wxString *arg3 = 0 ;
39152 wxMenu *arg4 = (wxMenu *) 0 ;
39153 wxString const &arg5_defvalue = wxPyEmptyString ;
39154 wxString *arg5 = (wxString *) &arg5_defvalue ;
39155 wxMenuItem *result = 0 ;
39156 void *argp1 = 0 ;
39157 int res1 = 0 ;
39158 int val2 ;
39159 int ecode2 = 0 ;
39160 bool temp3 = false ;
39161 void *argp4 = 0 ;
39162 int res4 = 0 ;
39163 bool temp5 = false ;
39164 PyObject * obj0 = 0 ;
39165 PyObject * obj1 = 0 ;
39166 PyObject * obj2 = 0 ;
39167 PyObject * obj3 = 0 ;
39168 PyObject * obj4 = 0 ;
39169 char * kwnames[] = {
39170 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39171 };
39172
39173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39175 if (!SWIG_IsOK(res1)) {
39176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39177 }
39178 arg1 = reinterpret_cast< wxMenu * >(argp1);
39179 ecode2 = SWIG_AsVal_int(obj1, &val2);
39180 if (!SWIG_IsOK(ecode2)) {
39181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39182 }
39183 arg2 = static_cast< int >(val2);
39184 {
39185 arg3 = wxString_in_helper(obj2);
39186 if (arg3 == NULL) SWIG_fail;
39187 temp3 = true;
39188 }
39189 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39190 if (!SWIG_IsOK(res4)) {
39191 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39192 }
39193 arg4 = reinterpret_cast< wxMenu * >(argp4);
39194 if (obj4) {
39195 {
39196 arg5 = wxString_in_helper(obj4);
39197 if (arg5 == NULL) SWIG_fail;
39198 temp5 = true;
39199 }
39200 }
39201 {
39202 PyThreadState* __tstate = wxPyBeginAllowThreads();
39203 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39204 wxPyEndAllowThreads(__tstate);
39205 if (PyErr_Occurred()) SWIG_fail;
39206 }
39207 {
39208 resultobj = wxPyMake_wxObject(result, (bool)0);
39209 }
39210 {
39211 if (temp3)
39212 delete arg3;
39213 }
39214 {
39215 if (temp5)
39216 delete arg5;
39217 }
39218 return resultobj;
39219 fail:
39220 {
39221 if (temp3)
39222 delete arg3;
39223 }
39224 {
39225 if (temp5)
39226 delete arg5;
39227 }
39228 return NULL;
39229 }
39230
39231
39232 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39233 PyObject *resultobj = 0;
39234 wxMenu *arg1 = (wxMenu *) 0 ;
39235 int arg2 ;
39236 wxMenuItem *result = 0 ;
39237 void *argp1 = 0 ;
39238 int res1 = 0 ;
39239 int val2 ;
39240 int ecode2 = 0 ;
39241 PyObject * obj0 = 0 ;
39242 PyObject * obj1 = 0 ;
39243 char * kwnames[] = {
39244 (char *) "self",(char *) "id", NULL
39245 };
39246
39247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39249 if (!SWIG_IsOK(res1)) {
39250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39251 }
39252 arg1 = reinterpret_cast< wxMenu * >(argp1);
39253 ecode2 = SWIG_AsVal_int(obj1, &val2);
39254 if (!SWIG_IsOK(ecode2)) {
39255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39256 }
39257 arg2 = static_cast< int >(val2);
39258 {
39259 PyThreadState* __tstate = wxPyBeginAllowThreads();
39260 result = (wxMenuItem *)(arg1)->Remove(arg2);
39261 wxPyEndAllowThreads(__tstate);
39262 if (PyErr_Occurred()) SWIG_fail;
39263 }
39264 {
39265 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39266 }
39267 return resultobj;
39268 fail:
39269 return NULL;
39270 }
39271
39272
39273 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39274 PyObject *resultobj = 0;
39275 wxMenu *arg1 = (wxMenu *) 0 ;
39276 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39277 wxMenuItem *result = 0 ;
39278 void *argp1 = 0 ;
39279 int res1 = 0 ;
39280 void *argp2 = 0 ;
39281 int res2 = 0 ;
39282 PyObject * obj0 = 0 ;
39283 PyObject * obj1 = 0 ;
39284 char * kwnames[] = {
39285 (char *) "self",(char *) "item", NULL
39286 };
39287
39288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39290 if (!SWIG_IsOK(res1)) {
39291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39292 }
39293 arg1 = reinterpret_cast< wxMenu * >(argp1);
39294 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39295 if (!SWIG_IsOK(res2)) {
39296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39297 }
39298 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39299 {
39300 PyThreadState* __tstate = wxPyBeginAllowThreads();
39301 result = (wxMenuItem *)(arg1)->Remove(arg2);
39302 wxPyEndAllowThreads(__tstate);
39303 if (PyErr_Occurred()) SWIG_fail;
39304 }
39305 {
39306 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39307 }
39308 return resultobj;
39309 fail:
39310 return NULL;
39311 }
39312
39313
39314 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39315 PyObject *resultobj = 0;
39316 wxMenu *arg1 = (wxMenu *) 0 ;
39317 int arg2 ;
39318 bool result;
39319 void *argp1 = 0 ;
39320 int res1 = 0 ;
39321 int val2 ;
39322 int ecode2 = 0 ;
39323 PyObject * obj0 = 0 ;
39324 PyObject * obj1 = 0 ;
39325 char * kwnames[] = {
39326 (char *) "self",(char *) "id", NULL
39327 };
39328
39329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39331 if (!SWIG_IsOK(res1)) {
39332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39333 }
39334 arg1 = reinterpret_cast< wxMenu * >(argp1);
39335 ecode2 = SWIG_AsVal_int(obj1, &val2);
39336 if (!SWIG_IsOK(ecode2)) {
39337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39338 }
39339 arg2 = static_cast< int >(val2);
39340 {
39341 PyThreadState* __tstate = wxPyBeginAllowThreads();
39342 result = (bool)(arg1)->Delete(arg2);
39343 wxPyEndAllowThreads(__tstate);
39344 if (PyErr_Occurred()) SWIG_fail;
39345 }
39346 {
39347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39348 }
39349 return resultobj;
39350 fail:
39351 return NULL;
39352 }
39353
39354
39355 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39356 PyObject *resultobj = 0;
39357 wxMenu *arg1 = (wxMenu *) 0 ;
39358 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39359 bool result;
39360 void *argp1 = 0 ;
39361 int res1 = 0 ;
39362 void *argp2 = 0 ;
39363 int res2 = 0 ;
39364 PyObject * obj0 = 0 ;
39365 PyObject * obj1 = 0 ;
39366 char * kwnames[] = {
39367 (char *) "self",(char *) "item", NULL
39368 };
39369
39370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39372 if (!SWIG_IsOK(res1)) {
39373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39374 }
39375 arg1 = reinterpret_cast< wxMenu * >(argp1);
39376 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39377 if (!SWIG_IsOK(res2)) {
39378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39379 }
39380 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39381 {
39382 PyThreadState* __tstate = wxPyBeginAllowThreads();
39383 result = (bool)(arg1)->Delete(arg2);
39384 wxPyEndAllowThreads(__tstate);
39385 if (PyErr_Occurred()) SWIG_fail;
39386 }
39387 {
39388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39389 }
39390 return resultobj;
39391 fail:
39392 return NULL;
39393 }
39394
39395
39396 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39397 PyObject *resultobj = 0;
39398 wxMenu *arg1 = (wxMenu *) 0 ;
39399 void *argp1 = 0 ;
39400 int res1 = 0 ;
39401 PyObject *swig_obj[1] ;
39402
39403 if (!args) SWIG_fail;
39404 swig_obj[0] = args;
39405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39406 if (!SWIG_IsOK(res1)) {
39407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39408 }
39409 arg1 = reinterpret_cast< wxMenu * >(argp1);
39410 {
39411 PyThreadState* __tstate = wxPyBeginAllowThreads();
39412 wxMenu_Destroy(arg1);
39413 wxPyEndAllowThreads(__tstate);
39414 if (PyErr_Occurred()) SWIG_fail;
39415 }
39416 resultobj = SWIG_Py_Void();
39417 return resultobj;
39418 fail:
39419 return NULL;
39420 }
39421
39422
39423 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39424 PyObject *resultobj = 0;
39425 wxMenu *arg1 = (wxMenu *) 0 ;
39426 int arg2 ;
39427 bool result;
39428 void *argp1 = 0 ;
39429 int res1 = 0 ;
39430 int val2 ;
39431 int ecode2 = 0 ;
39432 PyObject * obj0 = 0 ;
39433 PyObject * obj1 = 0 ;
39434 char * kwnames[] = {
39435 (char *) "self",(char *) "id", NULL
39436 };
39437
39438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39440 if (!SWIG_IsOK(res1)) {
39441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39442 }
39443 arg1 = reinterpret_cast< wxMenu * >(argp1);
39444 ecode2 = SWIG_AsVal_int(obj1, &val2);
39445 if (!SWIG_IsOK(ecode2)) {
39446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39447 }
39448 arg2 = static_cast< int >(val2);
39449 {
39450 PyThreadState* __tstate = wxPyBeginAllowThreads();
39451 result = (bool)(arg1)->Destroy(arg2);
39452 wxPyEndAllowThreads(__tstate);
39453 if (PyErr_Occurred()) SWIG_fail;
39454 }
39455 {
39456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39457 }
39458 return resultobj;
39459 fail:
39460 return NULL;
39461 }
39462
39463
39464 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39465 PyObject *resultobj = 0;
39466 wxMenu *arg1 = (wxMenu *) 0 ;
39467 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39468 bool result;
39469 void *argp1 = 0 ;
39470 int res1 = 0 ;
39471 void *argp2 = 0 ;
39472 int res2 = 0 ;
39473 PyObject * obj0 = 0 ;
39474 PyObject * obj1 = 0 ;
39475 char * kwnames[] = {
39476 (char *) "self",(char *) "item", NULL
39477 };
39478
39479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39481 if (!SWIG_IsOK(res1)) {
39482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39483 }
39484 arg1 = reinterpret_cast< wxMenu * >(argp1);
39485 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39486 if (!SWIG_IsOK(res2)) {
39487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39488 }
39489 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39490 {
39491 PyThreadState* __tstate = wxPyBeginAllowThreads();
39492 result = (bool)(arg1)->Destroy(arg2);
39493 wxPyEndAllowThreads(__tstate);
39494 if (PyErr_Occurred()) SWIG_fail;
39495 }
39496 {
39497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39498 }
39499 return resultobj;
39500 fail:
39501 return NULL;
39502 }
39503
39504
39505 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39506 PyObject *resultobj = 0;
39507 wxMenu *arg1 = (wxMenu *) 0 ;
39508 size_t result;
39509 void *argp1 = 0 ;
39510 int res1 = 0 ;
39511 PyObject *swig_obj[1] ;
39512
39513 if (!args) SWIG_fail;
39514 swig_obj[0] = args;
39515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39516 if (!SWIG_IsOK(res1)) {
39517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39518 }
39519 arg1 = reinterpret_cast< wxMenu * >(argp1);
39520 {
39521 PyThreadState* __tstate = wxPyBeginAllowThreads();
39522 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39523 wxPyEndAllowThreads(__tstate);
39524 if (PyErr_Occurred()) SWIG_fail;
39525 }
39526 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39527 return resultobj;
39528 fail:
39529 return NULL;
39530 }
39531
39532
39533 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39534 PyObject *resultobj = 0;
39535 wxMenu *arg1 = (wxMenu *) 0 ;
39536 PyObject *result = 0 ;
39537 void *argp1 = 0 ;
39538 int res1 = 0 ;
39539 PyObject *swig_obj[1] ;
39540
39541 if (!args) SWIG_fail;
39542 swig_obj[0] = args;
39543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39544 if (!SWIG_IsOK(res1)) {
39545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39546 }
39547 arg1 = reinterpret_cast< wxMenu * >(argp1);
39548 {
39549 PyThreadState* __tstate = wxPyBeginAllowThreads();
39550 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39551 wxPyEndAllowThreads(__tstate);
39552 if (PyErr_Occurred()) SWIG_fail;
39553 }
39554 resultobj = result;
39555 return resultobj;
39556 fail:
39557 return NULL;
39558 }
39559
39560
39561 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39562 PyObject *resultobj = 0;
39563 wxMenu *arg1 = (wxMenu *) 0 ;
39564 wxString *arg2 = 0 ;
39565 int result;
39566 void *argp1 = 0 ;
39567 int res1 = 0 ;
39568 bool temp2 = false ;
39569 PyObject * obj0 = 0 ;
39570 PyObject * obj1 = 0 ;
39571 char * kwnames[] = {
39572 (char *) "self",(char *) "item", NULL
39573 };
39574
39575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39577 if (!SWIG_IsOK(res1)) {
39578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39579 }
39580 arg1 = reinterpret_cast< wxMenu * >(argp1);
39581 {
39582 arg2 = wxString_in_helper(obj1);
39583 if (arg2 == NULL) SWIG_fail;
39584 temp2 = true;
39585 }
39586 {
39587 PyThreadState* __tstate = wxPyBeginAllowThreads();
39588 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39589 wxPyEndAllowThreads(__tstate);
39590 if (PyErr_Occurred()) SWIG_fail;
39591 }
39592 resultobj = SWIG_From_int(static_cast< int >(result));
39593 {
39594 if (temp2)
39595 delete arg2;
39596 }
39597 return resultobj;
39598 fail:
39599 {
39600 if (temp2)
39601 delete arg2;
39602 }
39603 return NULL;
39604 }
39605
39606
39607 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39608 PyObject *resultobj = 0;
39609 wxMenu *arg1 = (wxMenu *) 0 ;
39610 int arg2 ;
39611 wxMenuItem *result = 0 ;
39612 void *argp1 = 0 ;
39613 int res1 = 0 ;
39614 int val2 ;
39615 int ecode2 = 0 ;
39616 PyObject * obj0 = 0 ;
39617 PyObject * obj1 = 0 ;
39618 char * kwnames[] = {
39619 (char *) "self",(char *) "id", NULL
39620 };
39621
39622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39624 if (!SWIG_IsOK(res1)) {
39625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39626 }
39627 arg1 = reinterpret_cast< wxMenu * >(argp1);
39628 ecode2 = SWIG_AsVal_int(obj1, &val2);
39629 if (!SWIG_IsOK(ecode2)) {
39630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39631 }
39632 arg2 = static_cast< int >(val2);
39633 {
39634 PyThreadState* __tstate = wxPyBeginAllowThreads();
39635 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39636 wxPyEndAllowThreads(__tstate);
39637 if (PyErr_Occurred()) SWIG_fail;
39638 }
39639 {
39640 resultobj = wxPyMake_wxObject(result, (bool)0);
39641 }
39642 return resultobj;
39643 fail:
39644 return NULL;
39645 }
39646
39647
39648 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39649 PyObject *resultobj = 0;
39650 wxMenu *arg1 = (wxMenu *) 0 ;
39651 size_t arg2 ;
39652 wxMenuItem *result = 0 ;
39653 void *argp1 = 0 ;
39654 int res1 = 0 ;
39655 size_t val2 ;
39656 int ecode2 = 0 ;
39657 PyObject * obj0 = 0 ;
39658 PyObject * obj1 = 0 ;
39659 char * kwnames[] = {
39660 (char *) "self",(char *) "position", NULL
39661 };
39662
39663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39665 if (!SWIG_IsOK(res1)) {
39666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39667 }
39668 arg1 = reinterpret_cast< wxMenu * >(argp1);
39669 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39670 if (!SWIG_IsOK(ecode2)) {
39671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39672 }
39673 arg2 = static_cast< size_t >(val2);
39674 {
39675 PyThreadState* __tstate = wxPyBeginAllowThreads();
39676 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39677 wxPyEndAllowThreads(__tstate);
39678 if (PyErr_Occurred()) SWIG_fail;
39679 }
39680 {
39681 resultobj = wxPyMake_wxObject(result, (bool)0);
39682 }
39683 return resultobj;
39684 fail:
39685 return NULL;
39686 }
39687
39688
39689 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39690 PyObject *resultobj = 0;
39691 wxMenu *arg1 = (wxMenu *) 0 ;
39692 int arg2 ;
39693 bool arg3 ;
39694 void *argp1 = 0 ;
39695 int res1 = 0 ;
39696 int val2 ;
39697 int ecode2 = 0 ;
39698 bool val3 ;
39699 int ecode3 = 0 ;
39700 PyObject * obj0 = 0 ;
39701 PyObject * obj1 = 0 ;
39702 PyObject * obj2 = 0 ;
39703 char * kwnames[] = {
39704 (char *) "self",(char *) "id",(char *) "enable", NULL
39705 };
39706
39707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39709 if (!SWIG_IsOK(res1)) {
39710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39711 }
39712 arg1 = reinterpret_cast< wxMenu * >(argp1);
39713 ecode2 = SWIG_AsVal_int(obj1, &val2);
39714 if (!SWIG_IsOK(ecode2)) {
39715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
39716 }
39717 arg2 = static_cast< int >(val2);
39718 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39719 if (!SWIG_IsOK(ecode3)) {
39720 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39721 }
39722 arg3 = static_cast< bool >(val3);
39723 {
39724 PyThreadState* __tstate = wxPyBeginAllowThreads();
39725 (arg1)->Enable(arg2,arg3);
39726 wxPyEndAllowThreads(__tstate);
39727 if (PyErr_Occurred()) SWIG_fail;
39728 }
39729 resultobj = SWIG_Py_Void();
39730 return resultobj;
39731 fail:
39732 return NULL;
39733 }
39734
39735
39736 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39737 PyObject *resultobj = 0;
39738 wxMenu *arg1 = (wxMenu *) 0 ;
39739 int arg2 ;
39740 bool result;
39741 void *argp1 = 0 ;
39742 int res1 = 0 ;
39743 int val2 ;
39744 int ecode2 = 0 ;
39745 PyObject * obj0 = 0 ;
39746 PyObject * obj1 = 0 ;
39747 char * kwnames[] = {
39748 (char *) "self",(char *) "id", NULL
39749 };
39750
39751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
39752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39753 if (!SWIG_IsOK(res1)) {
39754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
39755 }
39756 arg1 = reinterpret_cast< wxMenu * >(argp1);
39757 ecode2 = SWIG_AsVal_int(obj1, &val2);
39758 if (!SWIG_IsOK(ecode2)) {
39759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
39760 }
39761 arg2 = static_cast< int >(val2);
39762 {
39763 PyThreadState* __tstate = wxPyBeginAllowThreads();
39764 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
39765 wxPyEndAllowThreads(__tstate);
39766 if (PyErr_Occurred()) SWIG_fail;
39767 }
39768 {
39769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39770 }
39771 return resultobj;
39772 fail:
39773 return NULL;
39774 }
39775
39776
39777 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39778 PyObject *resultobj = 0;
39779 wxMenu *arg1 = (wxMenu *) 0 ;
39780 int arg2 ;
39781 bool arg3 ;
39782 void *argp1 = 0 ;
39783 int res1 = 0 ;
39784 int val2 ;
39785 int ecode2 = 0 ;
39786 bool val3 ;
39787 int ecode3 = 0 ;
39788 PyObject * obj0 = 0 ;
39789 PyObject * obj1 = 0 ;
39790 PyObject * obj2 = 0 ;
39791 char * kwnames[] = {
39792 (char *) "self",(char *) "id",(char *) "check", NULL
39793 };
39794
39795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39797 if (!SWIG_IsOK(res1)) {
39798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
39799 }
39800 arg1 = reinterpret_cast< wxMenu * >(argp1);
39801 ecode2 = SWIG_AsVal_int(obj1, &val2);
39802 if (!SWIG_IsOK(ecode2)) {
39803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
39804 }
39805 arg2 = static_cast< int >(val2);
39806 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39807 if (!SWIG_IsOK(ecode3)) {
39808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
39809 }
39810 arg3 = static_cast< bool >(val3);
39811 {
39812 PyThreadState* __tstate = wxPyBeginAllowThreads();
39813 (arg1)->Check(arg2,arg3);
39814 wxPyEndAllowThreads(__tstate);
39815 if (PyErr_Occurred()) SWIG_fail;
39816 }
39817 resultobj = SWIG_Py_Void();
39818 return resultobj;
39819 fail:
39820 return NULL;
39821 }
39822
39823
39824 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39825 PyObject *resultobj = 0;
39826 wxMenu *arg1 = (wxMenu *) 0 ;
39827 int arg2 ;
39828 bool result;
39829 void *argp1 = 0 ;
39830 int res1 = 0 ;
39831 int val2 ;
39832 int ecode2 = 0 ;
39833 PyObject * obj0 = 0 ;
39834 PyObject * obj1 = 0 ;
39835 char * kwnames[] = {
39836 (char *) "self",(char *) "id", NULL
39837 };
39838
39839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
39840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39841 if (!SWIG_IsOK(res1)) {
39842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
39843 }
39844 arg1 = reinterpret_cast< wxMenu * >(argp1);
39845 ecode2 = SWIG_AsVal_int(obj1, &val2);
39846 if (!SWIG_IsOK(ecode2)) {
39847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
39848 }
39849 arg2 = static_cast< int >(val2);
39850 {
39851 PyThreadState* __tstate = wxPyBeginAllowThreads();
39852 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
39853 wxPyEndAllowThreads(__tstate);
39854 if (PyErr_Occurred()) SWIG_fail;
39855 }
39856 {
39857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39858 }
39859 return resultobj;
39860 fail:
39861 return NULL;
39862 }
39863
39864
39865 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39866 PyObject *resultobj = 0;
39867 wxMenu *arg1 = (wxMenu *) 0 ;
39868 int arg2 ;
39869 wxString *arg3 = 0 ;
39870 void *argp1 = 0 ;
39871 int res1 = 0 ;
39872 int val2 ;
39873 int ecode2 = 0 ;
39874 bool temp3 = false ;
39875 PyObject * obj0 = 0 ;
39876 PyObject * obj1 = 0 ;
39877 PyObject * obj2 = 0 ;
39878 char * kwnames[] = {
39879 (char *) "self",(char *) "id",(char *) "label", NULL
39880 };
39881
39882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39884 if (!SWIG_IsOK(res1)) {
39885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
39886 }
39887 arg1 = reinterpret_cast< wxMenu * >(argp1);
39888 ecode2 = SWIG_AsVal_int(obj1, &val2);
39889 if (!SWIG_IsOK(ecode2)) {
39890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
39891 }
39892 arg2 = static_cast< int >(val2);
39893 {
39894 arg3 = wxString_in_helper(obj2);
39895 if (arg3 == NULL) SWIG_fail;
39896 temp3 = true;
39897 }
39898 {
39899 PyThreadState* __tstate = wxPyBeginAllowThreads();
39900 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
39901 wxPyEndAllowThreads(__tstate);
39902 if (PyErr_Occurred()) SWIG_fail;
39903 }
39904 resultobj = SWIG_Py_Void();
39905 {
39906 if (temp3)
39907 delete arg3;
39908 }
39909 return resultobj;
39910 fail:
39911 {
39912 if (temp3)
39913 delete arg3;
39914 }
39915 return NULL;
39916 }
39917
39918
39919 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39920 PyObject *resultobj = 0;
39921 wxMenu *arg1 = (wxMenu *) 0 ;
39922 int arg2 ;
39923 wxString result;
39924 void *argp1 = 0 ;
39925 int res1 = 0 ;
39926 int val2 ;
39927 int ecode2 = 0 ;
39928 PyObject * obj0 = 0 ;
39929 PyObject * obj1 = 0 ;
39930 char * kwnames[] = {
39931 (char *) "self",(char *) "id", NULL
39932 };
39933
39934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
39935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39936 if (!SWIG_IsOK(res1)) {
39937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
39938 }
39939 arg1 = reinterpret_cast< wxMenu * >(argp1);
39940 ecode2 = SWIG_AsVal_int(obj1, &val2);
39941 if (!SWIG_IsOK(ecode2)) {
39942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
39943 }
39944 arg2 = static_cast< int >(val2);
39945 {
39946 PyThreadState* __tstate = wxPyBeginAllowThreads();
39947 result = ((wxMenu const *)arg1)->GetLabel(arg2);
39948 wxPyEndAllowThreads(__tstate);
39949 if (PyErr_Occurred()) SWIG_fail;
39950 }
39951 {
39952 #if wxUSE_UNICODE
39953 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39954 #else
39955 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39956 #endif
39957 }
39958 return resultobj;
39959 fail:
39960 return NULL;
39961 }
39962
39963
39964 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39965 PyObject *resultobj = 0;
39966 wxMenu *arg1 = (wxMenu *) 0 ;
39967 int arg2 ;
39968 wxString *arg3 = 0 ;
39969 void *argp1 = 0 ;
39970 int res1 = 0 ;
39971 int val2 ;
39972 int ecode2 = 0 ;
39973 bool temp3 = false ;
39974 PyObject * obj0 = 0 ;
39975 PyObject * obj1 = 0 ;
39976 PyObject * obj2 = 0 ;
39977 char * kwnames[] = {
39978 (char *) "self",(char *) "id",(char *) "helpString", NULL
39979 };
39980
39981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39983 if (!SWIG_IsOK(res1)) {
39984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
39985 }
39986 arg1 = reinterpret_cast< wxMenu * >(argp1);
39987 ecode2 = SWIG_AsVal_int(obj1, &val2);
39988 if (!SWIG_IsOK(ecode2)) {
39989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
39990 }
39991 arg2 = static_cast< int >(val2);
39992 {
39993 arg3 = wxString_in_helper(obj2);
39994 if (arg3 == NULL) SWIG_fail;
39995 temp3 = true;
39996 }
39997 {
39998 PyThreadState* __tstate = wxPyBeginAllowThreads();
39999 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40000 wxPyEndAllowThreads(__tstate);
40001 if (PyErr_Occurred()) SWIG_fail;
40002 }
40003 resultobj = SWIG_Py_Void();
40004 {
40005 if (temp3)
40006 delete arg3;
40007 }
40008 return resultobj;
40009 fail:
40010 {
40011 if (temp3)
40012 delete arg3;
40013 }
40014 return NULL;
40015 }
40016
40017
40018 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40019 PyObject *resultobj = 0;
40020 wxMenu *arg1 = (wxMenu *) 0 ;
40021 int arg2 ;
40022 wxString result;
40023 void *argp1 = 0 ;
40024 int res1 = 0 ;
40025 int val2 ;
40026 int ecode2 = 0 ;
40027 PyObject * obj0 = 0 ;
40028 PyObject * obj1 = 0 ;
40029 char * kwnames[] = {
40030 (char *) "self",(char *) "id", NULL
40031 };
40032
40033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40035 if (!SWIG_IsOK(res1)) {
40036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40037 }
40038 arg1 = reinterpret_cast< wxMenu * >(argp1);
40039 ecode2 = SWIG_AsVal_int(obj1, &val2);
40040 if (!SWIG_IsOK(ecode2)) {
40041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40042 }
40043 arg2 = static_cast< int >(val2);
40044 {
40045 PyThreadState* __tstate = wxPyBeginAllowThreads();
40046 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40047 wxPyEndAllowThreads(__tstate);
40048 if (PyErr_Occurred()) SWIG_fail;
40049 }
40050 {
40051 #if wxUSE_UNICODE
40052 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40053 #else
40054 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40055 #endif
40056 }
40057 return resultobj;
40058 fail:
40059 return NULL;
40060 }
40061
40062
40063 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40064 PyObject *resultobj = 0;
40065 wxMenu *arg1 = (wxMenu *) 0 ;
40066 wxString *arg2 = 0 ;
40067 void *argp1 = 0 ;
40068 int res1 = 0 ;
40069 bool temp2 = false ;
40070 PyObject * obj0 = 0 ;
40071 PyObject * obj1 = 0 ;
40072 char * kwnames[] = {
40073 (char *) "self",(char *) "title", NULL
40074 };
40075
40076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40078 if (!SWIG_IsOK(res1)) {
40079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40080 }
40081 arg1 = reinterpret_cast< wxMenu * >(argp1);
40082 {
40083 arg2 = wxString_in_helper(obj1);
40084 if (arg2 == NULL) SWIG_fail;
40085 temp2 = true;
40086 }
40087 {
40088 PyThreadState* __tstate = wxPyBeginAllowThreads();
40089 (arg1)->SetTitle((wxString const &)*arg2);
40090 wxPyEndAllowThreads(__tstate);
40091 if (PyErr_Occurred()) SWIG_fail;
40092 }
40093 resultobj = SWIG_Py_Void();
40094 {
40095 if (temp2)
40096 delete arg2;
40097 }
40098 return resultobj;
40099 fail:
40100 {
40101 if (temp2)
40102 delete arg2;
40103 }
40104 return NULL;
40105 }
40106
40107
40108 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40109 PyObject *resultobj = 0;
40110 wxMenu *arg1 = (wxMenu *) 0 ;
40111 wxString result;
40112 void *argp1 = 0 ;
40113 int res1 = 0 ;
40114 PyObject *swig_obj[1] ;
40115
40116 if (!args) SWIG_fail;
40117 swig_obj[0] = args;
40118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40119 if (!SWIG_IsOK(res1)) {
40120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40121 }
40122 arg1 = reinterpret_cast< wxMenu * >(argp1);
40123 {
40124 PyThreadState* __tstate = wxPyBeginAllowThreads();
40125 result = ((wxMenu const *)arg1)->GetTitle();
40126 wxPyEndAllowThreads(__tstate);
40127 if (PyErr_Occurred()) SWIG_fail;
40128 }
40129 {
40130 #if wxUSE_UNICODE
40131 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40132 #else
40133 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40134 #endif
40135 }
40136 return resultobj;
40137 fail:
40138 return NULL;
40139 }
40140
40141
40142 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40143 PyObject *resultobj = 0;
40144 wxMenu *arg1 = (wxMenu *) 0 ;
40145 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40146 void *argp1 = 0 ;
40147 int res1 = 0 ;
40148 void *argp2 = 0 ;
40149 int res2 = 0 ;
40150 PyObject * obj0 = 0 ;
40151 PyObject * obj1 = 0 ;
40152 char * kwnames[] = {
40153 (char *) "self",(char *) "handler", NULL
40154 };
40155
40156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40158 if (!SWIG_IsOK(res1)) {
40159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40160 }
40161 arg1 = reinterpret_cast< wxMenu * >(argp1);
40162 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40163 if (!SWIG_IsOK(res2)) {
40164 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40165 }
40166 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40167 {
40168 PyThreadState* __tstate = wxPyBeginAllowThreads();
40169 (arg1)->SetEventHandler(arg2);
40170 wxPyEndAllowThreads(__tstate);
40171 if (PyErr_Occurred()) SWIG_fail;
40172 }
40173 resultobj = SWIG_Py_Void();
40174 return resultobj;
40175 fail:
40176 return NULL;
40177 }
40178
40179
40180 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40181 PyObject *resultobj = 0;
40182 wxMenu *arg1 = (wxMenu *) 0 ;
40183 wxEvtHandler *result = 0 ;
40184 void *argp1 = 0 ;
40185 int res1 = 0 ;
40186 PyObject *swig_obj[1] ;
40187
40188 if (!args) SWIG_fail;
40189 swig_obj[0] = args;
40190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40191 if (!SWIG_IsOK(res1)) {
40192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40193 }
40194 arg1 = reinterpret_cast< wxMenu * >(argp1);
40195 {
40196 PyThreadState* __tstate = wxPyBeginAllowThreads();
40197 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40198 wxPyEndAllowThreads(__tstate);
40199 if (PyErr_Occurred()) SWIG_fail;
40200 }
40201 {
40202 resultobj = wxPyMake_wxObject(result, 0);
40203 }
40204 return resultobj;
40205 fail:
40206 return NULL;
40207 }
40208
40209
40210 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40211 PyObject *resultobj = 0;
40212 wxMenu *arg1 = (wxMenu *) 0 ;
40213 wxWindow *arg2 = (wxWindow *) 0 ;
40214 void *argp1 = 0 ;
40215 int res1 = 0 ;
40216 void *argp2 = 0 ;
40217 int res2 = 0 ;
40218 PyObject * obj0 = 0 ;
40219 PyObject * obj1 = 0 ;
40220 char * kwnames[] = {
40221 (char *) "self",(char *) "win", NULL
40222 };
40223
40224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40226 if (!SWIG_IsOK(res1)) {
40227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40228 }
40229 arg1 = reinterpret_cast< wxMenu * >(argp1);
40230 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40231 if (!SWIG_IsOK(res2)) {
40232 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40233 }
40234 arg2 = reinterpret_cast< wxWindow * >(argp2);
40235 {
40236 PyThreadState* __tstate = wxPyBeginAllowThreads();
40237 (arg1)->SetInvokingWindow(arg2);
40238 wxPyEndAllowThreads(__tstate);
40239 if (PyErr_Occurred()) SWIG_fail;
40240 }
40241 resultobj = SWIG_Py_Void();
40242 return resultobj;
40243 fail:
40244 return NULL;
40245 }
40246
40247
40248 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40249 PyObject *resultobj = 0;
40250 wxMenu *arg1 = (wxMenu *) 0 ;
40251 wxWindow *result = 0 ;
40252 void *argp1 = 0 ;
40253 int res1 = 0 ;
40254 PyObject *swig_obj[1] ;
40255
40256 if (!args) SWIG_fail;
40257 swig_obj[0] = args;
40258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40259 if (!SWIG_IsOK(res1)) {
40260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40261 }
40262 arg1 = reinterpret_cast< wxMenu * >(argp1);
40263 {
40264 PyThreadState* __tstate = wxPyBeginAllowThreads();
40265 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40266 wxPyEndAllowThreads(__tstate);
40267 if (PyErr_Occurred()) SWIG_fail;
40268 }
40269 {
40270 resultobj = wxPyMake_wxObject(result, 0);
40271 }
40272 return resultobj;
40273 fail:
40274 return NULL;
40275 }
40276
40277
40278 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40279 PyObject *resultobj = 0;
40280 wxMenu *arg1 = (wxMenu *) 0 ;
40281 long result;
40282 void *argp1 = 0 ;
40283 int res1 = 0 ;
40284 PyObject *swig_obj[1] ;
40285
40286 if (!args) SWIG_fail;
40287 swig_obj[0] = args;
40288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40289 if (!SWIG_IsOK(res1)) {
40290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40291 }
40292 arg1 = reinterpret_cast< wxMenu * >(argp1);
40293 {
40294 PyThreadState* __tstate = wxPyBeginAllowThreads();
40295 result = (long)((wxMenu const *)arg1)->GetStyle();
40296 wxPyEndAllowThreads(__tstate);
40297 if (PyErr_Occurred()) SWIG_fail;
40298 }
40299 resultobj = SWIG_From_long(static_cast< long >(result));
40300 return resultobj;
40301 fail:
40302 return NULL;
40303 }
40304
40305
40306 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40307 PyObject *resultobj = 0;
40308 wxMenu *arg1 = (wxMenu *) 0 ;
40309 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40310 void *argp1 = 0 ;
40311 int res1 = 0 ;
40312 void *argp2 = 0 ;
40313 int res2 = 0 ;
40314 PyObject * obj0 = 0 ;
40315 PyObject * obj1 = 0 ;
40316 char * kwnames[] = {
40317 (char *) "self",(char *) "source", NULL
40318 };
40319
40320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40322 if (!SWIG_IsOK(res1)) {
40323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40324 }
40325 arg1 = reinterpret_cast< wxMenu * >(argp1);
40326 if (obj1) {
40327 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40328 if (!SWIG_IsOK(res2)) {
40329 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40330 }
40331 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40332 }
40333 {
40334 PyThreadState* __tstate = wxPyBeginAllowThreads();
40335 (arg1)->UpdateUI(arg2);
40336 wxPyEndAllowThreads(__tstate);
40337 if (PyErr_Occurred()) SWIG_fail;
40338 }
40339 resultobj = SWIG_Py_Void();
40340 return resultobj;
40341 fail:
40342 return NULL;
40343 }
40344
40345
40346 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40347 PyObject *resultobj = 0;
40348 wxMenu *arg1 = (wxMenu *) 0 ;
40349 wxMenuBar *result = 0 ;
40350 void *argp1 = 0 ;
40351 int res1 = 0 ;
40352 PyObject *swig_obj[1] ;
40353
40354 if (!args) SWIG_fail;
40355 swig_obj[0] = args;
40356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40357 if (!SWIG_IsOK(res1)) {
40358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40359 }
40360 arg1 = reinterpret_cast< wxMenu * >(argp1);
40361 {
40362 PyThreadState* __tstate = wxPyBeginAllowThreads();
40363 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40364 wxPyEndAllowThreads(__tstate);
40365 if (PyErr_Occurred()) SWIG_fail;
40366 }
40367 {
40368 resultobj = wxPyMake_wxObject(result, (bool)0);
40369 }
40370 return resultobj;
40371 fail:
40372 return NULL;
40373 }
40374
40375
40376 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40377 PyObject *resultobj = 0;
40378 wxMenu *arg1 = (wxMenu *) 0 ;
40379 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40380 void *argp1 = 0 ;
40381 int res1 = 0 ;
40382 void *argp2 = 0 ;
40383 int res2 = 0 ;
40384 PyObject * obj0 = 0 ;
40385 PyObject * obj1 = 0 ;
40386 char * kwnames[] = {
40387 (char *) "self",(char *) "menubar", NULL
40388 };
40389
40390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40392 if (!SWIG_IsOK(res1)) {
40393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40394 }
40395 arg1 = reinterpret_cast< wxMenu * >(argp1);
40396 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40397 if (!SWIG_IsOK(res2)) {
40398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40399 }
40400 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40401 {
40402 PyThreadState* __tstate = wxPyBeginAllowThreads();
40403 (arg1)->Attach(arg2);
40404 wxPyEndAllowThreads(__tstate);
40405 if (PyErr_Occurred()) SWIG_fail;
40406 }
40407 resultobj = SWIG_Py_Void();
40408 return resultobj;
40409 fail:
40410 return NULL;
40411 }
40412
40413
40414 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40415 PyObject *resultobj = 0;
40416 wxMenu *arg1 = (wxMenu *) 0 ;
40417 void *argp1 = 0 ;
40418 int res1 = 0 ;
40419 PyObject *swig_obj[1] ;
40420
40421 if (!args) SWIG_fail;
40422 swig_obj[0] = args;
40423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40424 if (!SWIG_IsOK(res1)) {
40425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40426 }
40427 arg1 = reinterpret_cast< wxMenu * >(argp1);
40428 {
40429 PyThreadState* __tstate = wxPyBeginAllowThreads();
40430 (arg1)->Detach();
40431 wxPyEndAllowThreads(__tstate);
40432 if (PyErr_Occurred()) SWIG_fail;
40433 }
40434 resultobj = SWIG_Py_Void();
40435 return resultobj;
40436 fail:
40437 return NULL;
40438 }
40439
40440
40441 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40442 PyObject *resultobj = 0;
40443 wxMenu *arg1 = (wxMenu *) 0 ;
40444 bool result;
40445 void *argp1 = 0 ;
40446 int res1 = 0 ;
40447 PyObject *swig_obj[1] ;
40448
40449 if (!args) SWIG_fail;
40450 swig_obj[0] = args;
40451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40452 if (!SWIG_IsOK(res1)) {
40453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40454 }
40455 arg1 = reinterpret_cast< wxMenu * >(argp1);
40456 {
40457 PyThreadState* __tstate = wxPyBeginAllowThreads();
40458 result = (bool)((wxMenu const *)arg1)->IsAttached();
40459 wxPyEndAllowThreads(__tstate);
40460 if (PyErr_Occurred()) SWIG_fail;
40461 }
40462 {
40463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40464 }
40465 return resultobj;
40466 fail:
40467 return NULL;
40468 }
40469
40470
40471 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40472 PyObject *resultobj = 0;
40473 wxMenu *arg1 = (wxMenu *) 0 ;
40474 wxMenu *arg2 = (wxMenu *) 0 ;
40475 void *argp1 = 0 ;
40476 int res1 = 0 ;
40477 void *argp2 = 0 ;
40478 int res2 = 0 ;
40479 PyObject * obj0 = 0 ;
40480 PyObject * obj1 = 0 ;
40481 char * kwnames[] = {
40482 (char *) "self",(char *) "parent", NULL
40483 };
40484
40485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40487 if (!SWIG_IsOK(res1)) {
40488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40489 }
40490 arg1 = reinterpret_cast< wxMenu * >(argp1);
40491 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40492 if (!SWIG_IsOK(res2)) {
40493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40494 }
40495 arg2 = reinterpret_cast< wxMenu * >(argp2);
40496 {
40497 PyThreadState* __tstate = wxPyBeginAllowThreads();
40498 (arg1)->SetParent(arg2);
40499 wxPyEndAllowThreads(__tstate);
40500 if (PyErr_Occurred()) SWIG_fail;
40501 }
40502 resultobj = SWIG_Py_Void();
40503 return resultobj;
40504 fail:
40505 return NULL;
40506 }
40507
40508
40509 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40510 PyObject *resultobj = 0;
40511 wxMenu *arg1 = (wxMenu *) 0 ;
40512 wxMenu *result = 0 ;
40513 void *argp1 = 0 ;
40514 int res1 = 0 ;
40515 PyObject *swig_obj[1] ;
40516
40517 if (!args) SWIG_fail;
40518 swig_obj[0] = args;
40519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40520 if (!SWIG_IsOK(res1)) {
40521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40522 }
40523 arg1 = reinterpret_cast< wxMenu * >(argp1);
40524 {
40525 PyThreadState* __tstate = wxPyBeginAllowThreads();
40526 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40527 wxPyEndAllowThreads(__tstate);
40528 if (PyErr_Occurred()) SWIG_fail;
40529 }
40530 {
40531 resultobj = wxPyMake_wxObject(result, 0);
40532 }
40533 return resultobj;
40534 fail:
40535 return NULL;
40536 }
40537
40538
40539 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40540 PyObject *obj;
40541 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40542 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40543 return SWIG_Py_Void();
40544 }
40545
40546 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40547 return SWIG_Python_InitShadowInstance(args);
40548 }
40549
40550 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40551 PyObject *resultobj = 0;
40552 long arg1 = (long) 0 ;
40553 wxMenuBar *result = 0 ;
40554 long val1 ;
40555 int ecode1 = 0 ;
40556 PyObject * obj0 = 0 ;
40557 char * kwnames[] = {
40558 (char *) "style", NULL
40559 };
40560
40561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40562 if (obj0) {
40563 ecode1 = SWIG_AsVal_long(obj0, &val1);
40564 if (!SWIG_IsOK(ecode1)) {
40565 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40566 }
40567 arg1 = static_cast< long >(val1);
40568 }
40569 {
40570 if (!wxPyCheckForApp()) SWIG_fail;
40571 PyThreadState* __tstate = wxPyBeginAllowThreads();
40572 result = (wxMenuBar *)new wxMenuBar(arg1);
40573 wxPyEndAllowThreads(__tstate);
40574 if (PyErr_Occurred()) SWIG_fail;
40575 }
40576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40577 return resultobj;
40578 fail:
40579 return NULL;
40580 }
40581
40582
40583 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40584 PyObject *resultobj = 0;
40585 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40586 wxMenu *arg2 = (wxMenu *) 0 ;
40587 wxString *arg3 = 0 ;
40588 bool result;
40589 void *argp1 = 0 ;
40590 int res1 = 0 ;
40591 void *argp2 = 0 ;
40592 int res2 = 0 ;
40593 bool temp3 = false ;
40594 PyObject * obj0 = 0 ;
40595 PyObject * obj1 = 0 ;
40596 PyObject * obj2 = 0 ;
40597 char * kwnames[] = {
40598 (char *) "self",(char *) "menu",(char *) "title", NULL
40599 };
40600
40601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40603 if (!SWIG_IsOK(res1)) {
40604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40605 }
40606 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40608 if (!SWIG_IsOK(res2)) {
40609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40610 }
40611 arg2 = reinterpret_cast< wxMenu * >(argp2);
40612 {
40613 arg3 = wxString_in_helper(obj2);
40614 if (arg3 == NULL) SWIG_fail;
40615 temp3 = true;
40616 }
40617 {
40618 PyThreadState* __tstate = wxPyBeginAllowThreads();
40619 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40620 wxPyEndAllowThreads(__tstate);
40621 if (PyErr_Occurred()) SWIG_fail;
40622 }
40623 {
40624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40625 }
40626 {
40627 if (temp3)
40628 delete arg3;
40629 }
40630 return resultobj;
40631 fail:
40632 {
40633 if (temp3)
40634 delete arg3;
40635 }
40636 return NULL;
40637 }
40638
40639
40640 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40641 PyObject *resultobj = 0;
40642 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40643 size_t arg2 ;
40644 wxMenu *arg3 = (wxMenu *) 0 ;
40645 wxString *arg4 = 0 ;
40646 bool result;
40647 void *argp1 = 0 ;
40648 int res1 = 0 ;
40649 size_t val2 ;
40650 int ecode2 = 0 ;
40651 void *argp3 = 0 ;
40652 int res3 = 0 ;
40653 bool temp4 = false ;
40654 PyObject * obj0 = 0 ;
40655 PyObject * obj1 = 0 ;
40656 PyObject * obj2 = 0 ;
40657 PyObject * obj3 = 0 ;
40658 char * kwnames[] = {
40659 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40660 };
40661
40662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40664 if (!SWIG_IsOK(res1)) {
40665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40666 }
40667 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40668 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40669 if (!SWIG_IsOK(ecode2)) {
40670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40671 }
40672 arg2 = static_cast< size_t >(val2);
40673 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40674 if (!SWIG_IsOK(res3)) {
40675 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40676 }
40677 arg3 = reinterpret_cast< wxMenu * >(argp3);
40678 {
40679 arg4 = wxString_in_helper(obj3);
40680 if (arg4 == NULL) SWIG_fail;
40681 temp4 = true;
40682 }
40683 {
40684 PyThreadState* __tstate = wxPyBeginAllowThreads();
40685 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40686 wxPyEndAllowThreads(__tstate);
40687 if (PyErr_Occurred()) SWIG_fail;
40688 }
40689 {
40690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40691 }
40692 {
40693 if (temp4)
40694 delete arg4;
40695 }
40696 return resultobj;
40697 fail:
40698 {
40699 if (temp4)
40700 delete arg4;
40701 }
40702 return NULL;
40703 }
40704
40705
40706 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40707 PyObject *resultobj = 0;
40708 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40709 size_t result;
40710 void *argp1 = 0 ;
40711 int res1 = 0 ;
40712 PyObject *swig_obj[1] ;
40713
40714 if (!args) SWIG_fail;
40715 swig_obj[0] = args;
40716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40717 if (!SWIG_IsOK(res1)) {
40718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40719 }
40720 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40721 {
40722 PyThreadState* __tstate = wxPyBeginAllowThreads();
40723 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40724 wxPyEndAllowThreads(__tstate);
40725 if (PyErr_Occurred()) SWIG_fail;
40726 }
40727 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40728 return resultobj;
40729 fail:
40730 return NULL;
40731 }
40732
40733
40734 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40735 PyObject *resultobj = 0;
40736 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40737 size_t arg2 ;
40738 wxMenu *result = 0 ;
40739 void *argp1 = 0 ;
40740 int res1 = 0 ;
40741 size_t val2 ;
40742 int ecode2 = 0 ;
40743 PyObject * obj0 = 0 ;
40744 PyObject * obj1 = 0 ;
40745 char * kwnames[] = {
40746 (char *) "self",(char *) "pos", NULL
40747 };
40748
40749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
40750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40751 if (!SWIG_IsOK(res1)) {
40752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40753 }
40754 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40755 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40756 if (!SWIG_IsOK(ecode2)) {
40757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
40758 }
40759 arg2 = static_cast< size_t >(val2);
40760 {
40761 PyThreadState* __tstate = wxPyBeginAllowThreads();
40762 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
40763 wxPyEndAllowThreads(__tstate);
40764 if (PyErr_Occurred()) SWIG_fail;
40765 }
40766 {
40767 resultobj = wxPyMake_wxObject(result, 0);
40768 }
40769 return resultobj;
40770 fail:
40771 return NULL;
40772 }
40773
40774
40775 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40776 PyObject *resultobj = 0;
40777 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40778 size_t arg2 ;
40779 wxMenu *arg3 = (wxMenu *) 0 ;
40780 wxString *arg4 = 0 ;
40781 wxMenu *result = 0 ;
40782 void *argp1 = 0 ;
40783 int res1 = 0 ;
40784 size_t val2 ;
40785 int ecode2 = 0 ;
40786 void *argp3 = 0 ;
40787 int res3 = 0 ;
40788 bool temp4 = false ;
40789 PyObject * obj0 = 0 ;
40790 PyObject * obj1 = 0 ;
40791 PyObject * obj2 = 0 ;
40792 PyObject * obj3 = 0 ;
40793 char * kwnames[] = {
40794 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40795 };
40796
40797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40799 if (!SWIG_IsOK(res1)) {
40800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40801 }
40802 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40803 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40804 if (!SWIG_IsOK(ecode2)) {
40805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
40806 }
40807 arg2 = static_cast< size_t >(val2);
40808 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40809 if (!SWIG_IsOK(res3)) {
40810 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
40811 }
40812 arg3 = reinterpret_cast< wxMenu * >(argp3);
40813 {
40814 arg4 = wxString_in_helper(obj3);
40815 if (arg4 == NULL) SWIG_fail;
40816 temp4 = true;
40817 }
40818 {
40819 PyThreadState* __tstate = wxPyBeginAllowThreads();
40820 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
40821 wxPyEndAllowThreads(__tstate);
40822 if (PyErr_Occurred()) SWIG_fail;
40823 }
40824 {
40825 resultobj = wxPyMake_wxObject(result, 0);
40826 }
40827 {
40828 if (temp4)
40829 delete arg4;
40830 }
40831 return resultobj;
40832 fail:
40833 {
40834 if (temp4)
40835 delete arg4;
40836 }
40837 return NULL;
40838 }
40839
40840
40841 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40842 PyObject *resultobj = 0;
40843 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40844 size_t arg2 ;
40845 wxMenu *result = 0 ;
40846 void *argp1 = 0 ;
40847 int res1 = 0 ;
40848 size_t val2 ;
40849 int ecode2 = 0 ;
40850 PyObject * obj0 = 0 ;
40851 PyObject * obj1 = 0 ;
40852 char * kwnames[] = {
40853 (char *) "self",(char *) "pos", NULL
40854 };
40855
40856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40858 if (!SWIG_IsOK(res1)) {
40859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40860 }
40861 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40862 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40863 if (!SWIG_IsOK(ecode2)) {
40864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
40865 }
40866 arg2 = static_cast< size_t >(val2);
40867 {
40868 PyThreadState* __tstate = wxPyBeginAllowThreads();
40869 result = (wxMenu *)(arg1)->Remove(arg2);
40870 wxPyEndAllowThreads(__tstate);
40871 if (PyErr_Occurred()) SWIG_fail;
40872 }
40873 {
40874 resultobj = wxPyMake_wxObject(result, 0);
40875 }
40876 return resultobj;
40877 fail:
40878 return NULL;
40879 }
40880
40881
40882 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40883 PyObject *resultobj = 0;
40884 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40885 size_t arg2 ;
40886 bool arg3 ;
40887 void *argp1 = 0 ;
40888 int res1 = 0 ;
40889 size_t val2 ;
40890 int ecode2 = 0 ;
40891 bool val3 ;
40892 int ecode3 = 0 ;
40893 PyObject * obj0 = 0 ;
40894 PyObject * obj1 = 0 ;
40895 PyObject * obj2 = 0 ;
40896 char * kwnames[] = {
40897 (char *) "self",(char *) "pos",(char *) "enable", NULL
40898 };
40899
40900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40902 if (!SWIG_IsOK(res1)) {
40903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40904 }
40905 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40906 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40907 if (!SWIG_IsOK(ecode2)) {
40908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
40909 }
40910 arg2 = static_cast< size_t >(val2);
40911 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40912 if (!SWIG_IsOK(ecode3)) {
40913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
40914 }
40915 arg3 = static_cast< bool >(val3);
40916 {
40917 PyThreadState* __tstate = wxPyBeginAllowThreads();
40918 (arg1)->EnableTop(arg2,arg3);
40919 wxPyEndAllowThreads(__tstate);
40920 if (PyErr_Occurred()) SWIG_fail;
40921 }
40922 resultobj = SWIG_Py_Void();
40923 return resultobj;
40924 fail:
40925 return NULL;
40926 }
40927
40928
40929 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40930 PyObject *resultobj = 0;
40931 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40932 size_t arg2 ;
40933 bool result;
40934 void *argp1 = 0 ;
40935 int res1 = 0 ;
40936 size_t val2 ;
40937 int ecode2 = 0 ;
40938 PyObject * obj0 = 0 ;
40939 PyObject * obj1 = 0 ;
40940 char * kwnames[] = {
40941 (char *) "self",(char *) "pos", NULL
40942 };
40943
40944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
40945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40946 if (!SWIG_IsOK(res1)) {
40947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40948 }
40949 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40950 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40951 if (!SWIG_IsOK(ecode2)) {
40952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
40953 }
40954 arg2 = static_cast< size_t >(val2);
40955 {
40956 PyThreadState* __tstate = wxPyBeginAllowThreads();
40957 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
40958 wxPyEndAllowThreads(__tstate);
40959 if (PyErr_Occurred()) SWIG_fail;
40960 }
40961 {
40962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40963 }
40964 return resultobj;
40965 fail:
40966 return NULL;
40967 }
40968
40969
40970 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40971 PyObject *resultobj = 0;
40972 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40973 size_t arg2 ;
40974 wxString *arg3 = 0 ;
40975 void *argp1 = 0 ;
40976 int res1 = 0 ;
40977 size_t val2 ;
40978 int ecode2 = 0 ;
40979 bool temp3 = false ;
40980 PyObject * obj0 = 0 ;
40981 PyObject * obj1 = 0 ;
40982 PyObject * obj2 = 0 ;
40983 char * kwnames[] = {
40984 (char *) "self",(char *) "pos",(char *) "label", NULL
40985 };
40986
40987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40989 if (!SWIG_IsOK(res1)) {
40990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40991 }
40992 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40993 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40994 if (!SWIG_IsOK(ecode2)) {
40995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
40996 }
40997 arg2 = static_cast< size_t >(val2);
40998 {
40999 arg3 = wxString_in_helper(obj2);
41000 if (arg3 == NULL) SWIG_fail;
41001 temp3 = true;
41002 }
41003 {
41004 PyThreadState* __tstate = wxPyBeginAllowThreads();
41005 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41006 wxPyEndAllowThreads(__tstate);
41007 if (PyErr_Occurred()) SWIG_fail;
41008 }
41009 resultobj = SWIG_Py_Void();
41010 {
41011 if (temp3)
41012 delete arg3;
41013 }
41014 return resultobj;
41015 fail:
41016 {
41017 if (temp3)
41018 delete arg3;
41019 }
41020 return NULL;
41021 }
41022
41023
41024 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41025 PyObject *resultobj = 0;
41026 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41027 size_t arg2 ;
41028 wxString result;
41029 void *argp1 = 0 ;
41030 int res1 = 0 ;
41031 size_t val2 ;
41032 int ecode2 = 0 ;
41033 PyObject * obj0 = 0 ;
41034 PyObject * obj1 = 0 ;
41035 char * kwnames[] = {
41036 (char *) "self",(char *) "pos", NULL
41037 };
41038
41039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41041 if (!SWIG_IsOK(res1)) {
41042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41043 }
41044 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41045 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41046 if (!SWIG_IsOK(ecode2)) {
41047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41048 }
41049 arg2 = static_cast< size_t >(val2);
41050 {
41051 PyThreadState* __tstate = wxPyBeginAllowThreads();
41052 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41053 wxPyEndAllowThreads(__tstate);
41054 if (PyErr_Occurred()) SWIG_fail;
41055 }
41056 {
41057 #if wxUSE_UNICODE
41058 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41059 #else
41060 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41061 #endif
41062 }
41063 return resultobj;
41064 fail:
41065 return NULL;
41066 }
41067
41068
41069 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41070 PyObject *resultobj = 0;
41071 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41072 wxString *arg2 = 0 ;
41073 wxString *arg3 = 0 ;
41074 int result;
41075 void *argp1 = 0 ;
41076 int res1 = 0 ;
41077 bool temp2 = false ;
41078 bool temp3 = false ;
41079 PyObject * obj0 = 0 ;
41080 PyObject * obj1 = 0 ;
41081 PyObject * obj2 = 0 ;
41082 char * kwnames[] = {
41083 (char *) "self",(char *) "menu",(char *) "item", NULL
41084 };
41085
41086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41088 if (!SWIG_IsOK(res1)) {
41089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41090 }
41091 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41092 {
41093 arg2 = wxString_in_helper(obj1);
41094 if (arg2 == NULL) SWIG_fail;
41095 temp2 = true;
41096 }
41097 {
41098 arg3 = wxString_in_helper(obj2);
41099 if (arg3 == NULL) SWIG_fail;
41100 temp3 = true;
41101 }
41102 {
41103 PyThreadState* __tstate = wxPyBeginAllowThreads();
41104 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41105 wxPyEndAllowThreads(__tstate);
41106 if (PyErr_Occurred()) SWIG_fail;
41107 }
41108 resultobj = SWIG_From_int(static_cast< int >(result));
41109 {
41110 if (temp2)
41111 delete arg2;
41112 }
41113 {
41114 if (temp3)
41115 delete arg3;
41116 }
41117 return resultobj;
41118 fail:
41119 {
41120 if (temp2)
41121 delete arg2;
41122 }
41123 {
41124 if (temp3)
41125 delete arg3;
41126 }
41127 return NULL;
41128 }
41129
41130
41131 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41132 PyObject *resultobj = 0;
41133 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41134 int arg2 ;
41135 wxMenuItem *result = 0 ;
41136 void *argp1 = 0 ;
41137 int res1 = 0 ;
41138 int val2 ;
41139 int ecode2 = 0 ;
41140 PyObject * obj0 = 0 ;
41141 PyObject * obj1 = 0 ;
41142 char * kwnames[] = {
41143 (char *) "self",(char *) "id", NULL
41144 };
41145
41146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41148 if (!SWIG_IsOK(res1)) {
41149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41150 }
41151 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41152 ecode2 = SWIG_AsVal_int(obj1, &val2);
41153 if (!SWIG_IsOK(ecode2)) {
41154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41155 }
41156 arg2 = static_cast< int >(val2);
41157 {
41158 PyThreadState* __tstate = wxPyBeginAllowThreads();
41159 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41160 wxPyEndAllowThreads(__tstate);
41161 if (PyErr_Occurred()) SWIG_fail;
41162 }
41163 {
41164 resultobj = wxPyMake_wxObject(result, (bool)0);
41165 }
41166 return resultobj;
41167 fail:
41168 return NULL;
41169 }
41170
41171
41172 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41173 PyObject *resultobj = 0;
41174 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41175 wxString *arg2 = 0 ;
41176 int result;
41177 void *argp1 = 0 ;
41178 int res1 = 0 ;
41179 bool temp2 = false ;
41180 PyObject * obj0 = 0 ;
41181 PyObject * obj1 = 0 ;
41182 char * kwnames[] = {
41183 (char *) "self",(char *) "title", NULL
41184 };
41185
41186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41188 if (!SWIG_IsOK(res1)) {
41189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41190 }
41191 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41192 {
41193 arg2 = wxString_in_helper(obj1);
41194 if (arg2 == NULL) SWIG_fail;
41195 temp2 = true;
41196 }
41197 {
41198 PyThreadState* __tstate = wxPyBeginAllowThreads();
41199 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41200 wxPyEndAllowThreads(__tstate);
41201 if (PyErr_Occurred()) SWIG_fail;
41202 }
41203 resultobj = SWIG_From_int(static_cast< int >(result));
41204 {
41205 if (temp2)
41206 delete arg2;
41207 }
41208 return resultobj;
41209 fail:
41210 {
41211 if (temp2)
41212 delete arg2;
41213 }
41214 return NULL;
41215 }
41216
41217
41218 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41219 PyObject *resultobj = 0;
41220 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41221 int arg2 ;
41222 bool arg3 ;
41223 void *argp1 = 0 ;
41224 int res1 = 0 ;
41225 int val2 ;
41226 int ecode2 = 0 ;
41227 bool val3 ;
41228 int ecode3 = 0 ;
41229 PyObject * obj0 = 0 ;
41230 PyObject * obj1 = 0 ;
41231 PyObject * obj2 = 0 ;
41232 char * kwnames[] = {
41233 (char *) "self",(char *) "id",(char *) "enable", NULL
41234 };
41235
41236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41238 if (!SWIG_IsOK(res1)) {
41239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41240 }
41241 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41242 ecode2 = SWIG_AsVal_int(obj1, &val2);
41243 if (!SWIG_IsOK(ecode2)) {
41244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41245 }
41246 arg2 = static_cast< int >(val2);
41247 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41248 if (!SWIG_IsOK(ecode3)) {
41249 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41250 }
41251 arg3 = static_cast< bool >(val3);
41252 {
41253 PyThreadState* __tstate = wxPyBeginAllowThreads();
41254 (arg1)->Enable(arg2,arg3);
41255 wxPyEndAllowThreads(__tstate);
41256 if (PyErr_Occurred()) SWIG_fail;
41257 }
41258 resultobj = SWIG_Py_Void();
41259 return resultobj;
41260 fail:
41261 return NULL;
41262 }
41263
41264
41265 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41266 PyObject *resultobj = 0;
41267 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41268 int arg2 ;
41269 bool arg3 ;
41270 void *argp1 = 0 ;
41271 int res1 = 0 ;
41272 int val2 ;
41273 int ecode2 = 0 ;
41274 bool val3 ;
41275 int ecode3 = 0 ;
41276 PyObject * obj0 = 0 ;
41277 PyObject * obj1 = 0 ;
41278 PyObject * obj2 = 0 ;
41279 char * kwnames[] = {
41280 (char *) "self",(char *) "id",(char *) "check", NULL
41281 };
41282
41283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41285 if (!SWIG_IsOK(res1)) {
41286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41287 }
41288 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41289 ecode2 = SWIG_AsVal_int(obj1, &val2);
41290 if (!SWIG_IsOK(ecode2)) {
41291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41292 }
41293 arg2 = static_cast< int >(val2);
41294 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41295 if (!SWIG_IsOK(ecode3)) {
41296 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41297 }
41298 arg3 = static_cast< bool >(val3);
41299 {
41300 PyThreadState* __tstate = wxPyBeginAllowThreads();
41301 (arg1)->Check(arg2,arg3);
41302 wxPyEndAllowThreads(__tstate);
41303 if (PyErr_Occurred()) SWIG_fail;
41304 }
41305 resultobj = SWIG_Py_Void();
41306 return resultobj;
41307 fail:
41308 return NULL;
41309 }
41310
41311
41312 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41313 PyObject *resultobj = 0;
41314 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41315 int arg2 ;
41316 bool result;
41317 void *argp1 = 0 ;
41318 int res1 = 0 ;
41319 int val2 ;
41320 int ecode2 = 0 ;
41321 PyObject * obj0 = 0 ;
41322 PyObject * obj1 = 0 ;
41323 char * kwnames[] = {
41324 (char *) "self",(char *) "id", NULL
41325 };
41326
41327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41329 if (!SWIG_IsOK(res1)) {
41330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41331 }
41332 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41333 ecode2 = SWIG_AsVal_int(obj1, &val2);
41334 if (!SWIG_IsOK(ecode2)) {
41335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41336 }
41337 arg2 = static_cast< int >(val2);
41338 {
41339 PyThreadState* __tstate = wxPyBeginAllowThreads();
41340 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41341 wxPyEndAllowThreads(__tstate);
41342 if (PyErr_Occurred()) SWIG_fail;
41343 }
41344 {
41345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41346 }
41347 return resultobj;
41348 fail:
41349 return NULL;
41350 }
41351
41352
41353 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41354 PyObject *resultobj = 0;
41355 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41356 int arg2 ;
41357 bool result;
41358 void *argp1 = 0 ;
41359 int res1 = 0 ;
41360 int val2 ;
41361 int ecode2 = 0 ;
41362 PyObject * obj0 = 0 ;
41363 PyObject * obj1 = 0 ;
41364 char * kwnames[] = {
41365 (char *) "self",(char *) "id", NULL
41366 };
41367
41368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41370 if (!SWIG_IsOK(res1)) {
41371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41372 }
41373 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41374 ecode2 = SWIG_AsVal_int(obj1, &val2);
41375 if (!SWIG_IsOK(ecode2)) {
41376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41377 }
41378 arg2 = static_cast< int >(val2);
41379 {
41380 PyThreadState* __tstate = wxPyBeginAllowThreads();
41381 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41382 wxPyEndAllowThreads(__tstate);
41383 if (PyErr_Occurred()) SWIG_fail;
41384 }
41385 {
41386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41387 }
41388 return resultobj;
41389 fail:
41390 return NULL;
41391 }
41392
41393
41394 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41395 PyObject *resultobj = 0;
41396 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41397 int arg2 ;
41398 wxString *arg3 = 0 ;
41399 void *argp1 = 0 ;
41400 int res1 = 0 ;
41401 int val2 ;
41402 int ecode2 = 0 ;
41403 bool temp3 = false ;
41404 PyObject * obj0 = 0 ;
41405 PyObject * obj1 = 0 ;
41406 PyObject * obj2 = 0 ;
41407 char * kwnames[] = {
41408 (char *) "self",(char *) "id",(char *) "label", NULL
41409 };
41410
41411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41413 if (!SWIG_IsOK(res1)) {
41414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41415 }
41416 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41417 ecode2 = SWIG_AsVal_int(obj1, &val2);
41418 if (!SWIG_IsOK(ecode2)) {
41419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41420 }
41421 arg2 = static_cast< int >(val2);
41422 {
41423 arg3 = wxString_in_helper(obj2);
41424 if (arg3 == NULL) SWIG_fail;
41425 temp3 = true;
41426 }
41427 {
41428 PyThreadState* __tstate = wxPyBeginAllowThreads();
41429 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41430 wxPyEndAllowThreads(__tstate);
41431 if (PyErr_Occurred()) SWIG_fail;
41432 }
41433 resultobj = SWIG_Py_Void();
41434 {
41435 if (temp3)
41436 delete arg3;
41437 }
41438 return resultobj;
41439 fail:
41440 {
41441 if (temp3)
41442 delete arg3;
41443 }
41444 return NULL;
41445 }
41446
41447
41448 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41449 PyObject *resultobj = 0;
41450 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41451 int arg2 ;
41452 wxString result;
41453 void *argp1 = 0 ;
41454 int res1 = 0 ;
41455 int val2 ;
41456 int ecode2 = 0 ;
41457 PyObject * obj0 = 0 ;
41458 PyObject * obj1 = 0 ;
41459 char * kwnames[] = {
41460 (char *) "self",(char *) "id", NULL
41461 };
41462
41463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41465 if (!SWIG_IsOK(res1)) {
41466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41467 }
41468 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41469 ecode2 = SWIG_AsVal_int(obj1, &val2);
41470 if (!SWIG_IsOK(ecode2)) {
41471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41472 }
41473 arg2 = static_cast< int >(val2);
41474 {
41475 PyThreadState* __tstate = wxPyBeginAllowThreads();
41476 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41477 wxPyEndAllowThreads(__tstate);
41478 if (PyErr_Occurred()) SWIG_fail;
41479 }
41480 {
41481 #if wxUSE_UNICODE
41482 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41483 #else
41484 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41485 #endif
41486 }
41487 return resultobj;
41488 fail:
41489 return NULL;
41490 }
41491
41492
41493 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41494 PyObject *resultobj = 0;
41495 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41496 int arg2 ;
41497 wxString *arg3 = 0 ;
41498 void *argp1 = 0 ;
41499 int res1 = 0 ;
41500 int val2 ;
41501 int ecode2 = 0 ;
41502 bool temp3 = false ;
41503 PyObject * obj0 = 0 ;
41504 PyObject * obj1 = 0 ;
41505 PyObject * obj2 = 0 ;
41506 char * kwnames[] = {
41507 (char *) "self",(char *) "id",(char *) "helpString", NULL
41508 };
41509
41510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41512 if (!SWIG_IsOK(res1)) {
41513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41514 }
41515 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41516 ecode2 = SWIG_AsVal_int(obj1, &val2);
41517 if (!SWIG_IsOK(ecode2)) {
41518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41519 }
41520 arg2 = static_cast< int >(val2);
41521 {
41522 arg3 = wxString_in_helper(obj2);
41523 if (arg3 == NULL) SWIG_fail;
41524 temp3 = true;
41525 }
41526 {
41527 PyThreadState* __tstate = wxPyBeginAllowThreads();
41528 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41529 wxPyEndAllowThreads(__tstate);
41530 if (PyErr_Occurred()) SWIG_fail;
41531 }
41532 resultobj = SWIG_Py_Void();
41533 {
41534 if (temp3)
41535 delete arg3;
41536 }
41537 return resultobj;
41538 fail:
41539 {
41540 if (temp3)
41541 delete arg3;
41542 }
41543 return NULL;
41544 }
41545
41546
41547 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41548 PyObject *resultobj = 0;
41549 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41550 int arg2 ;
41551 wxString result;
41552 void *argp1 = 0 ;
41553 int res1 = 0 ;
41554 int val2 ;
41555 int ecode2 = 0 ;
41556 PyObject * obj0 = 0 ;
41557 PyObject * obj1 = 0 ;
41558 char * kwnames[] = {
41559 (char *) "self",(char *) "id", NULL
41560 };
41561
41562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41564 if (!SWIG_IsOK(res1)) {
41565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41566 }
41567 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41568 ecode2 = SWIG_AsVal_int(obj1, &val2);
41569 if (!SWIG_IsOK(ecode2)) {
41570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41571 }
41572 arg2 = static_cast< int >(val2);
41573 {
41574 PyThreadState* __tstate = wxPyBeginAllowThreads();
41575 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41576 wxPyEndAllowThreads(__tstate);
41577 if (PyErr_Occurred()) SWIG_fail;
41578 }
41579 {
41580 #if wxUSE_UNICODE
41581 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41582 #else
41583 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41584 #endif
41585 }
41586 return resultobj;
41587 fail:
41588 return NULL;
41589 }
41590
41591
41592 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41593 PyObject *resultobj = 0;
41594 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41595 wxFrame *result = 0 ;
41596 void *argp1 = 0 ;
41597 int res1 = 0 ;
41598 PyObject *swig_obj[1] ;
41599
41600 if (!args) SWIG_fail;
41601 swig_obj[0] = args;
41602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41603 if (!SWIG_IsOK(res1)) {
41604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41605 }
41606 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41607 {
41608 PyThreadState* __tstate = wxPyBeginAllowThreads();
41609 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41610 wxPyEndAllowThreads(__tstate);
41611 if (PyErr_Occurred()) SWIG_fail;
41612 }
41613 {
41614 resultobj = wxPyMake_wxObject(result, (bool)0);
41615 }
41616 return resultobj;
41617 fail:
41618 return NULL;
41619 }
41620
41621
41622 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41623 PyObject *resultobj = 0;
41624 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41625 bool result;
41626 void *argp1 = 0 ;
41627 int res1 = 0 ;
41628 PyObject *swig_obj[1] ;
41629
41630 if (!args) SWIG_fail;
41631 swig_obj[0] = args;
41632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41633 if (!SWIG_IsOK(res1)) {
41634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41635 }
41636 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41637 {
41638 PyThreadState* __tstate = wxPyBeginAllowThreads();
41639 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41640 wxPyEndAllowThreads(__tstate);
41641 if (PyErr_Occurred()) SWIG_fail;
41642 }
41643 {
41644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41645 }
41646 return resultobj;
41647 fail:
41648 return NULL;
41649 }
41650
41651
41652 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41653 PyObject *resultobj = 0;
41654 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41655 wxFrame *arg2 = (wxFrame *) 0 ;
41656 void *argp1 = 0 ;
41657 int res1 = 0 ;
41658 void *argp2 = 0 ;
41659 int res2 = 0 ;
41660 PyObject * obj0 = 0 ;
41661 PyObject * obj1 = 0 ;
41662 char * kwnames[] = {
41663 (char *) "self",(char *) "frame", NULL
41664 };
41665
41666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41668 if (!SWIG_IsOK(res1)) {
41669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41670 }
41671 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41672 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41673 if (!SWIG_IsOK(res2)) {
41674 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41675 }
41676 arg2 = reinterpret_cast< wxFrame * >(argp2);
41677 {
41678 PyThreadState* __tstate = wxPyBeginAllowThreads();
41679 (arg1)->Attach(arg2);
41680 wxPyEndAllowThreads(__tstate);
41681 if (PyErr_Occurred()) SWIG_fail;
41682 }
41683 resultobj = SWIG_Py_Void();
41684 return resultobj;
41685 fail:
41686 return NULL;
41687 }
41688
41689
41690 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41691 PyObject *resultobj = 0;
41692 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41693 void *argp1 = 0 ;
41694 int res1 = 0 ;
41695 PyObject *swig_obj[1] ;
41696
41697 if (!args) SWIG_fail;
41698 swig_obj[0] = args;
41699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41700 if (!SWIG_IsOK(res1)) {
41701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41702 }
41703 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41704 {
41705 PyThreadState* __tstate = wxPyBeginAllowThreads();
41706 (arg1)->Detach();
41707 wxPyEndAllowThreads(__tstate);
41708 if (PyErr_Occurred()) SWIG_fail;
41709 }
41710 resultobj = SWIG_Py_Void();
41711 return resultobj;
41712 fail:
41713 return NULL;
41714 }
41715
41716
41717 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41718 PyObject *resultobj = 0;
41719 bool arg1 ;
41720 bool val1 ;
41721 int ecode1 = 0 ;
41722 PyObject * obj0 = 0 ;
41723 char * kwnames[] = {
41724 (char *) "enable", NULL
41725 };
41726
41727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41728 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41729 if (!SWIG_IsOK(ecode1)) {
41730 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41731 }
41732 arg1 = static_cast< bool >(val1);
41733 {
41734 PyThreadState* __tstate = wxPyBeginAllowThreads();
41735 wxMenuBar_SetAutoWindowMenu(arg1);
41736 wxPyEndAllowThreads(__tstate);
41737 if (PyErr_Occurred()) SWIG_fail;
41738 }
41739 resultobj = SWIG_Py_Void();
41740 return resultobj;
41741 fail:
41742 return NULL;
41743 }
41744
41745
41746 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41747 PyObject *resultobj = 0;
41748 bool result;
41749
41750 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
41751 {
41752 PyThreadState* __tstate = wxPyBeginAllowThreads();
41753 result = (bool)wxMenuBar_GetAutoWindowMenu();
41754 wxPyEndAllowThreads(__tstate);
41755 if (PyErr_Occurred()) SWIG_fail;
41756 }
41757 {
41758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41759 }
41760 return resultobj;
41761 fail:
41762 return NULL;
41763 }
41764
41765
41766 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41767 PyObject *obj;
41768 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41769 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
41770 return SWIG_Py_Void();
41771 }
41772
41773 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41774 return SWIG_Python_InitShadowInstance(args);
41775 }
41776
41777 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41778 PyObject *resultobj = 0;
41779 wxMenu *arg1 = (wxMenu *) NULL ;
41780 int arg2 = (int) wxID_ANY ;
41781 wxString const &arg3_defvalue = wxPyEmptyString ;
41782 wxString *arg3 = (wxString *) &arg3_defvalue ;
41783 wxString const &arg4_defvalue = wxPyEmptyString ;
41784 wxString *arg4 = (wxString *) &arg4_defvalue ;
41785 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41786 wxMenu *arg6 = (wxMenu *) NULL ;
41787 wxMenuItem *result = 0 ;
41788 void *argp1 = 0 ;
41789 int res1 = 0 ;
41790 int val2 ;
41791 int ecode2 = 0 ;
41792 bool temp3 = false ;
41793 bool temp4 = false ;
41794 int val5 ;
41795 int ecode5 = 0 ;
41796 void *argp6 = 0 ;
41797 int res6 = 0 ;
41798 PyObject * obj0 = 0 ;
41799 PyObject * obj1 = 0 ;
41800 PyObject * obj2 = 0 ;
41801 PyObject * obj3 = 0 ;
41802 PyObject * obj4 = 0 ;
41803 PyObject * obj5 = 0 ;
41804 char * kwnames[] = {
41805 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
41806 };
41807
41808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
41809 if (obj0) {
41810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41811 if (!SWIG_IsOK(res1)) {
41812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41813 }
41814 arg1 = reinterpret_cast< wxMenu * >(argp1);
41815 }
41816 if (obj1) {
41817 ecode2 = SWIG_AsVal_int(obj1, &val2);
41818 if (!SWIG_IsOK(ecode2)) {
41819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
41820 }
41821 arg2 = static_cast< int >(val2);
41822 }
41823 if (obj2) {
41824 {
41825 arg3 = wxString_in_helper(obj2);
41826 if (arg3 == NULL) SWIG_fail;
41827 temp3 = true;
41828 }
41829 }
41830 if (obj3) {
41831 {
41832 arg4 = wxString_in_helper(obj3);
41833 if (arg4 == NULL) SWIG_fail;
41834 temp4 = true;
41835 }
41836 }
41837 if (obj4) {
41838 ecode5 = SWIG_AsVal_int(obj4, &val5);
41839 if (!SWIG_IsOK(ecode5)) {
41840 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
41841 }
41842 arg5 = static_cast< wxItemKind >(val5);
41843 }
41844 if (obj5) {
41845 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
41846 if (!SWIG_IsOK(res6)) {
41847 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
41848 }
41849 arg6 = reinterpret_cast< wxMenu * >(argp6);
41850 }
41851 {
41852 PyThreadState* __tstate = wxPyBeginAllowThreads();
41853 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
41854 wxPyEndAllowThreads(__tstate);
41855 if (PyErr_Occurred()) SWIG_fail;
41856 }
41857 {
41858 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
41859 }
41860 {
41861 if (temp3)
41862 delete arg3;
41863 }
41864 {
41865 if (temp4)
41866 delete arg4;
41867 }
41868 return resultobj;
41869 fail:
41870 {
41871 if (temp3)
41872 delete arg3;
41873 }
41874 {
41875 if (temp4)
41876 delete arg4;
41877 }
41878 return NULL;
41879 }
41880
41881
41882 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41883 PyObject *resultobj = 0;
41884 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41885 void *argp1 = 0 ;
41886 int res1 = 0 ;
41887 PyObject *swig_obj[1] ;
41888
41889 if (!args) SWIG_fail;
41890 swig_obj[0] = args;
41891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
41892 if (!SWIG_IsOK(res1)) {
41893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41894 }
41895 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41896 {
41897 PyThreadState* __tstate = wxPyBeginAllowThreads();
41898 delete arg1;
41899
41900 wxPyEndAllowThreads(__tstate);
41901 if (PyErr_Occurred()) SWIG_fail;
41902 }
41903 resultobj = SWIG_Py_Void();
41904 return resultobj;
41905 fail:
41906 return NULL;
41907 }
41908
41909
41910 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41911 PyObject *resultobj = 0;
41912 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41913 wxMenu *result = 0 ;
41914 void *argp1 = 0 ;
41915 int res1 = 0 ;
41916 PyObject *swig_obj[1] ;
41917
41918 if (!args) SWIG_fail;
41919 swig_obj[0] = args;
41920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41921 if (!SWIG_IsOK(res1)) {
41922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
41923 }
41924 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41925 {
41926 PyThreadState* __tstate = wxPyBeginAllowThreads();
41927 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
41928 wxPyEndAllowThreads(__tstate);
41929 if (PyErr_Occurred()) SWIG_fail;
41930 }
41931 {
41932 resultobj = wxPyMake_wxObject(result, 0);
41933 }
41934 return resultobj;
41935 fail:
41936 return NULL;
41937 }
41938
41939
41940 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41941 PyObject *resultobj = 0;
41942 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41943 wxMenu *arg2 = (wxMenu *) 0 ;
41944 void *argp1 = 0 ;
41945 int res1 = 0 ;
41946 void *argp2 = 0 ;
41947 int res2 = 0 ;
41948 PyObject * obj0 = 0 ;
41949 PyObject * obj1 = 0 ;
41950 char * kwnames[] = {
41951 (char *) "self",(char *) "menu", NULL
41952 };
41953
41954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41956 if (!SWIG_IsOK(res1)) {
41957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41958 }
41959 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41960 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41961 if (!SWIG_IsOK(res2)) {
41962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
41963 }
41964 arg2 = reinterpret_cast< wxMenu * >(argp2);
41965 {
41966 PyThreadState* __tstate = wxPyBeginAllowThreads();
41967 (arg1)->SetMenu(arg2);
41968 wxPyEndAllowThreads(__tstate);
41969 if (PyErr_Occurred()) SWIG_fail;
41970 }
41971 resultobj = SWIG_Py_Void();
41972 return resultobj;
41973 fail:
41974 return NULL;
41975 }
41976
41977
41978 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41979 PyObject *resultobj = 0;
41980 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41981 int arg2 ;
41982 void *argp1 = 0 ;
41983 int res1 = 0 ;
41984 int val2 ;
41985 int ecode2 = 0 ;
41986 PyObject * obj0 = 0 ;
41987 PyObject * obj1 = 0 ;
41988 char * kwnames[] = {
41989 (char *) "self",(char *) "id", NULL
41990 };
41991
41992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
41993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41994 if (!SWIG_IsOK(res1)) {
41995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41996 }
41997 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41998 ecode2 = SWIG_AsVal_int(obj1, &val2);
41999 if (!SWIG_IsOK(ecode2)) {
42000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42001 }
42002 arg2 = static_cast< int >(val2);
42003 {
42004 PyThreadState* __tstate = wxPyBeginAllowThreads();
42005 (arg1)->SetId(arg2);
42006 wxPyEndAllowThreads(__tstate);
42007 if (PyErr_Occurred()) SWIG_fail;
42008 }
42009 resultobj = SWIG_Py_Void();
42010 return resultobj;
42011 fail:
42012 return NULL;
42013 }
42014
42015
42016 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42017 PyObject *resultobj = 0;
42018 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42019 int result;
42020 void *argp1 = 0 ;
42021 int res1 = 0 ;
42022 PyObject *swig_obj[1] ;
42023
42024 if (!args) SWIG_fail;
42025 swig_obj[0] = args;
42026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42027 if (!SWIG_IsOK(res1)) {
42028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42029 }
42030 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42031 {
42032 PyThreadState* __tstate = wxPyBeginAllowThreads();
42033 result = (int)((wxMenuItem const *)arg1)->GetId();
42034 wxPyEndAllowThreads(__tstate);
42035 if (PyErr_Occurred()) SWIG_fail;
42036 }
42037 resultobj = SWIG_From_int(static_cast< int >(result));
42038 return resultobj;
42039 fail:
42040 return NULL;
42041 }
42042
42043
42044 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42045 PyObject *resultobj = 0;
42046 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42047 bool result;
42048 void *argp1 = 0 ;
42049 int res1 = 0 ;
42050 PyObject *swig_obj[1] ;
42051
42052 if (!args) SWIG_fail;
42053 swig_obj[0] = args;
42054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42055 if (!SWIG_IsOK(res1)) {
42056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42057 }
42058 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42059 {
42060 PyThreadState* __tstate = wxPyBeginAllowThreads();
42061 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42062 wxPyEndAllowThreads(__tstate);
42063 if (PyErr_Occurred()) SWIG_fail;
42064 }
42065 {
42066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42067 }
42068 return resultobj;
42069 fail:
42070 return NULL;
42071 }
42072
42073
42074 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42075 PyObject *resultobj = 0;
42076 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42077 wxString *arg2 = 0 ;
42078 void *argp1 = 0 ;
42079 int res1 = 0 ;
42080 bool temp2 = false ;
42081 PyObject * obj0 = 0 ;
42082 PyObject * obj1 = 0 ;
42083 char * kwnames[] = {
42084 (char *) "self",(char *) "str", NULL
42085 };
42086
42087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42089 if (!SWIG_IsOK(res1)) {
42090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42091 }
42092 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42093 {
42094 arg2 = wxString_in_helper(obj1);
42095 if (arg2 == NULL) SWIG_fail;
42096 temp2 = true;
42097 }
42098 {
42099 PyThreadState* __tstate = wxPyBeginAllowThreads();
42100 (arg1)->SetText((wxString const &)*arg2);
42101 wxPyEndAllowThreads(__tstate);
42102 if (PyErr_Occurred()) SWIG_fail;
42103 }
42104 resultobj = SWIG_Py_Void();
42105 {
42106 if (temp2)
42107 delete arg2;
42108 }
42109 return resultobj;
42110 fail:
42111 {
42112 if (temp2)
42113 delete arg2;
42114 }
42115 return NULL;
42116 }
42117
42118
42119 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42120 PyObject *resultobj = 0;
42121 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42122 wxString result;
42123 void *argp1 = 0 ;
42124 int res1 = 0 ;
42125 PyObject *swig_obj[1] ;
42126
42127 if (!args) SWIG_fail;
42128 swig_obj[0] = args;
42129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42130 if (!SWIG_IsOK(res1)) {
42131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42132 }
42133 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42134 {
42135 PyThreadState* __tstate = wxPyBeginAllowThreads();
42136 result = ((wxMenuItem const *)arg1)->GetLabel();
42137 wxPyEndAllowThreads(__tstate);
42138 if (PyErr_Occurred()) SWIG_fail;
42139 }
42140 {
42141 #if wxUSE_UNICODE
42142 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42143 #else
42144 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42145 #endif
42146 }
42147 return resultobj;
42148 fail:
42149 return NULL;
42150 }
42151
42152
42153 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42154 PyObject *resultobj = 0;
42155 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42156 wxString *result = 0 ;
42157 void *argp1 = 0 ;
42158 int res1 = 0 ;
42159 PyObject *swig_obj[1] ;
42160
42161 if (!args) SWIG_fail;
42162 swig_obj[0] = args;
42163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42164 if (!SWIG_IsOK(res1)) {
42165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42166 }
42167 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42168 {
42169 PyThreadState* __tstate = wxPyBeginAllowThreads();
42170 {
42171 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42172 result = (wxString *) &_result_ref;
42173 }
42174 wxPyEndAllowThreads(__tstate);
42175 if (PyErr_Occurred()) SWIG_fail;
42176 }
42177 {
42178 #if wxUSE_UNICODE
42179 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42180 #else
42181 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42182 #endif
42183 }
42184 return resultobj;
42185 fail:
42186 return NULL;
42187 }
42188
42189
42190 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42191 PyObject *resultobj = 0;
42192 wxString *arg1 = 0 ;
42193 wxString result;
42194 bool temp1 = false ;
42195 PyObject * obj0 = 0 ;
42196 char * kwnames[] = {
42197 (char *) "text", NULL
42198 };
42199
42200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42201 {
42202 arg1 = wxString_in_helper(obj0);
42203 if (arg1 == NULL) SWIG_fail;
42204 temp1 = true;
42205 }
42206 {
42207 PyThreadState* __tstate = wxPyBeginAllowThreads();
42208 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42209 wxPyEndAllowThreads(__tstate);
42210 if (PyErr_Occurred()) SWIG_fail;
42211 }
42212 {
42213 #if wxUSE_UNICODE
42214 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42215 #else
42216 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42217 #endif
42218 }
42219 {
42220 if (temp1)
42221 delete arg1;
42222 }
42223 return resultobj;
42224 fail:
42225 {
42226 if (temp1)
42227 delete arg1;
42228 }
42229 return NULL;
42230 }
42231
42232
42233 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42234 PyObject *resultobj = 0;
42235 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42236 wxItemKind result;
42237 void *argp1 = 0 ;
42238 int res1 = 0 ;
42239 PyObject *swig_obj[1] ;
42240
42241 if (!args) SWIG_fail;
42242 swig_obj[0] = args;
42243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42244 if (!SWIG_IsOK(res1)) {
42245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42246 }
42247 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42248 {
42249 PyThreadState* __tstate = wxPyBeginAllowThreads();
42250 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42251 wxPyEndAllowThreads(__tstate);
42252 if (PyErr_Occurred()) SWIG_fail;
42253 }
42254 resultobj = SWIG_From_int(static_cast< int >(result));
42255 return resultobj;
42256 fail:
42257 return NULL;
42258 }
42259
42260
42261 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42262 PyObject *resultobj = 0;
42263 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42264 wxItemKind arg2 ;
42265 void *argp1 = 0 ;
42266 int res1 = 0 ;
42267 int val2 ;
42268 int ecode2 = 0 ;
42269 PyObject * obj0 = 0 ;
42270 PyObject * obj1 = 0 ;
42271 char * kwnames[] = {
42272 (char *) "self",(char *) "kind", NULL
42273 };
42274
42275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42277 if (!SWIG_IsOK(res1)) {
42278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42279 }
42280 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42281 ecode2 = SWIG_AsVal_int(obj1, &val2);
42282 if (!SWIG_IsOK(ecode2)) {
42283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42284 }
42285 arg2 = static_cast< wxItemKind >(val2);
42286 {
42287 PyThreadState* __tstate = wxPyBeginAllowThreads();
42288 (arg1)->SetKind(arg2);
42289 wxPyEndAllowThreads(__tstate);
42290 if (PyErr_Occurred()) SWIG_fail;
42291 }
42292 resultobj = SWIG_Py_Void();
42293 return resultobj;
42294 fail:
42295 return NULL;
42296 }
42297
42298
42299 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42300 PyObject *resultobj = 0;
42301 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42302 bool arg2 ;
42303 void *argp1 = 0 ;
42304 int res1 = 0 ;
42305 bool val2 ;
42306 int ecode2 = 0 ;
42307 PyObject * obj0 = 0 ;
42308 PyObject * obj1 = 0 ;
42309 char * kwnames[] = {
42310 (char *) "self",(char *) "checkable", NULL
42311 };
42312
42313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42315 if (!SWIG_IsOK(res1)) {
42316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42317 }
42318 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42319 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42320 if (!SWIG_IsOK(ecode2)) {
42321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42322 }
42323 arg2 = static_cast< bool >(val2);
42324 {
42325 PyThreadState* __tstate = wxPyBeginAllowThreads();
42326 (arg1)->SetCheckable(arg2);
42327 wxPyEndAllowThreads(__tstate);
42328 if (PyErr_Occurred()) SWIG_fail;
42329 }
42330 resultobj = SWIG_Py_Void();
42331 return resultobj;
42332 fail:
42333 return NULL;
42334 }
42335
42336
42337 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42338 PyObject *resultobj = 0;
42339 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42340 bool result;
42341 void *argp1 = 0 ;
42342 int res1 = 0 ;
42343 PyObject *swig_obj[1] ;
42344
42345 if (!args) SWIG_fail;
42346 swig_obj[0] = args;
42347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42348 if (!SWIG_IsOK(res1)) {
42349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42350 }
42351 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42352 {
42353 PyThreadState* __tstate = wxPyBeginAllowThreads();
42354 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42355 wxPyEndAllowThreads(__tstate);
42356 if (PyErr_Occurred()) SWIG_fail;
42357 }
42358 {
42359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42360 }
42361 return resultobj;
42362 fail:
42363 return NULL;
42364 }
42365
42366
42367 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42368 PyObject *resultobj = 0;
42369 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42370 bool result;
42371 void *argp1 = 0 ;
42372 int res1 = 0 ;
42373 PyObject *swig_obj[1] ;
42374
42375 if (!args) SWIG_fail;
42376 swig_obj[0] = args;
42377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42378 if (!SWIG_IsOK(res1)) {
42379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42380 }
42381 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42382 {
42383 PyThreadState* __tstate = wxPyBeginAllowThreads();
42384 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42385 wxPyEndAllowThreads(__tstate);
42386 if (PyErr_Occurred()) SWIG_fail;
42387 }
42388 {
42389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42390 }
42391 return resultobj;
42392 fail:
42393 return NULL;
42394 }
42395
42396
42397 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42398 PyObject *resultobj = 0;
42399 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42400 wxMenu *arg2 = (wxMenu *) 0 ;
42401 void *argp1 = 0 ;
42402 int res1 = 0 ;
42403 void *argp2 = 0 ;
42404 int res2 = 0 ;
42405 PyObject * obj0 = 0 ;
42406 PyObject * obj1 = 0 ;
42407 char * kwnames[] = {
42408 (char *) "self",(char *) "menu", NULL
42409 };
42410
42411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42413 if (!SWIG_IsOK(res1)) {
42414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42415 }
42416 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42417 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42418 if (!SWIG_IsOK(res2)) {
42419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42420 }
42421 arg2 = reinterpret_cast< wxMenu * >(argp2);
42422 {
42423 PyThreadState* __tstate = wxPyBeginAllowThreads();
42424 (arg1)->SetSubMenu(arg2);
42425 wxPyEndAllowThreads(__tstate);
42426 if (PyErr_Occurred()) SWIG_fail;
42427 }
42428 resultobj = SWIG_Py_Void();
42429 return resultobj;
42430 fail:
42431 return NULL;
42432 }
42433
42434
42435 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42436 PyObject *resultobj = 0;
42437 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42438 wxMenu *result = 0 ;
42439 void *argp1 = 0 ;
42440 int res1 = 0 ;
42441 PyObject *swig_obj[1] ;
42442
42443 if (!args) SWIG_fail;
42444 swig_obj[0] = args;
42445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42446 if (!SWIG_IsOK(res1)) {
42447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42448 }
42449 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42450 {
42451 PyThreadState* __tstate = wxPyBeginAllowThreads();
42452 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42453 wxPyEndAllowThreads(__tstate);
42454 if (PyErr_Occurred()) SWIG_fail;
42455 }
42456 {
42457 resultobj = wxPyMake_wxObject(result, 0);
42458 }
42459 return resultobj;
42460 fail:
42461 return NULL;
42462 }
42463
42464
42465 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42466 PyObject *resultobj = 0;
42467 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42468 bool arg2 = (bool) true ;
42469 void *argp1 = 0 ;
42470 int res1 = 0 ;
42471 bool val2 ;
42472 int ecode2 = 0 ;
42473 PyObject * obj0 = 0 ;
42474 PyObject * obj1 = 0 ;
42475 char * kwnames[] = {
42476 (char *) "self",(char *) "enable", NULL
42477 };
42478
42479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42481 if (!SWIG_IsOK(res1)) {
42482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42483 }
42484 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42485 if (obj1) {
42486 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42487 if (!SWIG_IsOK(ecode2)) {
42488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42489 }
42490 arg2 = static_cast< bool >(val2);
42491 }
42492 {
42493 PyThreadState* __tstate = wxPyBeginAllowThreads();
42494 (arg1)->Enable(arg2);
42495 wxPyEndAllowThreads(__tstate);
42496 if (PyErr_Occurred()) SWIG_fail;
42497 }
42498 resultobj = SWIG_Py_Void();
42499 return resultobj;
42500 fail:
42501 return NULL;
42502 }
42503
42504
42505 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42506 PyObject *resultobj = 0;
42507 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42508 bool result;
42509 void *argp1 = 0 ;
42510 int res1 = 0 ;
42511 PyObject *swig_obj[1] ;
42512
42513 if (!args) SWIG_fail;
42514 swig_obj[0] = args;
42515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42516 if (!SWIG_IsOK(res1)) {
42517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42518 }
42519 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42520 {
42521 PyThreadState* __tstate = wxPyBeginAllowThreads();
42522 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42523 wxPyEndAllowThreads(__tstate);
42524 if (PyErr_Occurred()) SWIG_fail;
42525 }
42526 {
42527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42528 }
42529 return resultobj;
42530 fail:
42531 return NULL;
42532 }
42533
42534
42535 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42536 PyObject *resultobj = 0;
42537 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42538 bool arg2 = (bool) true ;
42539 void *argp1 = 0 ;
42540 int res1 = 0 ;
42541 bool val2 ;
42542 int ecode2 = 0 ;
42543 PyObject * obj0 = 0 ;
42544 PyObject * obj1 = 0 ;
42545 char * kwnames[] = {
42546 (char *) "self",(char *) "check", NULL
42547 };
42548
42549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42551 if (!SWIG_IsOK(res1)) {
42552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42553 }
42554 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42555 if (obj1) {
42556 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42557 if (!SWIG_IsOK(ecode2)) {
42558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42559 }
42560 arg2 = static_cast< bool >(val2);
42561 }
42562 {
42563 PyThreadState* __tstate = wxPyBeginAllowThreads();
42564 (arg1)->Check(arg2);
42565 wxPyEndAllowThreads(__tstate);
42566 if (PyErr_Occurred()) SWIG_fail;
42567 }
42568 resultobj = SWIG_Py_Void();
42569 return resultobj;
42570 fail:
42571 return NULL;
42572 }
42573
42574
42575 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42576 PyObject *resultobj = 0;
42577 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42578 bool result;
42579 void *argp1 = 0 ;
42580 int res1 = 0 ;
42581 PyObject *swig_obj[1] ;
42582
42583 if (!args) SWIG_fail;
42584 swig_obj[0] = args;
42585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42586 if (!SWIG_IsOK(res1)) {
42587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42588 }
42589 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42590 {
42591 PyThreadState* __tstate = wxPyBeginAllowThreads();
42592 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42593 wxPyEndAllowThreads(__tstate);
42594 if (PyErr_Occurred()) SWIG_fail;
42595 }
42596 {
42597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42598 }
42599 return resultobj;
42600 fail:
42601 return NULL;
42602 }
42603
42604
42605 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42606 PyObject *resultobj = 0;
42607 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42608 void *argp1 = 0 ;
42609 int res1 = 0 ;
42610 PyObject *swig_obj[1] ;
42611
42612 if (!args) SWIG_fail;
42613 swig_obj[0] = args;
42614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42615 if (!SWIG_IsOK(res1)) {
42616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42617 }
42618 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42619 {
42620 PyThreadState* __tstate = wxPyBeginAllowThreads();
42621 (arg1)->Toggle();
42622 wxPyEndAllowThreads(__tstate);
42623 if (PyErr_Occurred()) SWIG_fail;
42624 }
42625 resultobj = SWIG_Py_Void();
42626 return resultobj;
42627 fail:
42628 return NULL;
42629 }
42630
42631
42632 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42633 PyObject *resultobj = 0;
42634 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42635 wxString *arg2 = 0 ;
42636 void *argp1 = 0 ;
42637 int res1 = 0 ;
42638 bool temp2 = false ;
42639 PyObject * obj0 = 0 ;
42640 PyObject * obj1 = 0 ;
42641 char * kwnames[] = {
42642 (char *) "self",(char *) "str", NULL
42643 };
42644
42645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42647 if (!SWIG_IsOK(res1)) {
42648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42649 }
42650 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42651 {
42652 arg2 = wxString_in_helper(obj1);
42653 if (arg2 == NULL) SWIG_fail;
42654 temp2 = true;
42655 }
42656 {
42657 PyThreadState* __tstate = wxPyBeginAllowThreads();
42658 (arg1)->SetHelp((wxString const &)*arg2);
42659 wxPyEndAllowThreads(__tstate);
42660 if (PyErr_Occurred()) SWIG_fail;
42661 }
42662 resultobj = SWIG_Py_Void();
42663 {
42664 if (temp2)
42665 delete arg2;
42666 }
42667 return resultobj;
42668 fail:
42669 {
42670 if (temp2)
42671 delete arg2;
42672 }
42673 return NULL;
42674 }
42675
42676
42677 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42678 PyObject *resultobj = 0;
42679 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42680 wxString *result = 0 ;
42681 void *argp1 = 0 ;
42682 int res1 = 0 ;
42683 PyObject *swig_obj[1] ;
42684
42685 if (!args) SWIG_fail;
42686 swig_obj[0] = args;
42687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42688 if (!SWIG_IsOK(res1)) {
42689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42690 }
42691 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42692 {
42693 PyThreadState* __tstate = wxPyBeginAllowThreads();
42694 {
42695 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42696 result = (wxString *) &_result_ref;
42697 }
42698 wxPyEndAllowThreads(__tstate);
42699 if (PyErr_Occurred()) SWIG_fail;
42700 }
42701 {
42702 #if wxUSE_UNICODE
42703 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42704 #else
42705 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42706 #endif
42707 }
42708 return resultobj;
42709 fail:
42710 return NULL;
42711 }
42712
42713
42714 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42715 PyObject *resultobj = 0;
42716 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42717 wxAcceleratorEntry *result = 0 ;
42718 void *argp1 = 0 ;
42719 int res1 = 0 ;
42720 PyObject *swig_obj[1] ;
42721
42722 if (!args) SWIG_fail;
42723 swig_obj[0] = args;
42724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42725 if (!SWIG_IsOK(res1)) {
42726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42727 }
42728 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42729 {
42730 PyThreadState* __tstate = wxPyBeginAllowThreads();
42731 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42732 wxPyEndAllowThreads(__tstate);
42733 if (PyErr_Occurred()) SWIG_fail;
42734 }
42735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42736 return resultobj;
42737 fail:
42738 return NULL;
42739 }
42740
42741
42742 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42743 PyObject *resultobj = 0;
42744 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42745 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
42746 void *argp1 = 0 ;
42747 int res1 = 0 ;
42748 void *argp2 = 0 ;
42749 int res2 = 0 ;
42750 PyObject * obj0 = 0 ;
42751 PyObject * obj1 = 0 ;
42752 char * kwnames[] = {
42753 (char *) "self",(char *) "accel", NULL
42754 };
42755
42756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
42757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42758 if (!SWIG_IsOK(res1)) {
42759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42760 }
42761 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42762 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42763 if (!SWIG_IsOK(res2)) {
42764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
42765 }
42766 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
42767 {
42768 PyThreadState* __tstate = wxPyBeginAllowThreads();
42769 (arg1)->SetAccel(arg2);
42770 wxPyEndAllowThreads(__tstate);
42771 if (PyErr_Occurred()) SWIG_fail;
42772 }
42773 resultobj = SWIG_Py_Void();
42774 return resultobj;
42775 fail:
42776 return NULL;
42777 }
42778
42779
42780 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42781 PyObject *resultobj = 0;
42782 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42783 wxBitmap *arg2 = 0 ;
42784 void *argp1 = 0 ;
42785 int res1 = 0 ;
42786 void *argp2 = 0 ;
42787 int res2 = 0 ;
42788 PyObject * obj0 = 0 ;
42789 PyObject * obj1 = 0 ;
42790 char * kwnames[] = {
42791 (char *) "self",(char *) "bitmap", NULL
42792 };
42793
42794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
42795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42796 if (!SWIG_IsOK(res1)) {
42797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42798 }
42799 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42800 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
42801 if (!SWIG_IsOK(res2)) {
42802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42803 }
42804 if (!argp2) {
42805 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42806 }
42807 arg2 = reinterpret_cast< wxBitmap * >(argp2);
42808 {
42809 PyThreadState* __tstate = wxPyBeginAllowThreads();
42810 (arg1)->SetBitmap((wxBitmap const &)*arg2);
42811 wxPyEndAllowThreads(__tstate);
42812 if (PyErr_Occurred()) SWIG_fail;
42813 }
42814 resultobj = SWIG_Py_Void();
42815 return resultobj;
42816 fail:
42817 return NULL;
42818 }
42819
42820
42821 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42822 PyObject *resultobj = 0;
42823 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42824 wxBitmap *result = 0 ;
42825 void *argp1 = 0 ;
42826 int res1 = 0 ;
42827 PyObject *swig_obj[1] ;
42828
42829 if (!args) SWIG_fail;
42830 swig_obj[0] = args;
42831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42832 if (!SWIG_IsOK(res1)) {
42833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42834 }
42835 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42836 {
42837 PyThreadState* __tstate = wxPyBeginAllowThreads();
42838 {
42839 wxBitmap const &_result_ref = (arg1)->GetBitmap();
42840 result = (wxBitmap *) &_result_ref;
42841 }
42842 wxPyEndAllowThreads(__tstate);
42843 if (PyErr_Occurred()) SWIG_fail;
42844 }
42845 {
42846 wxBitmap* resultptr = new wxBitmap(*result);
42847 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
42848 }
42849 return resultobj;
42850 fail:
42851 return NULL;
42852 }
42853
42854
42855 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42856 PyObject *resultobj = 0;
42857 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42858 wxFont *arg2 = 0 ;
42859 void *argp1 = 0 ;
42860 int res1 = 0 ;
42861 void *argp2 = 0 ;
42862 int res2 = 0 ;
42863 PyObject * obj0 = 0 ;
42864 PyObject * obj1 = 0 ;
42865 char * kwnames[] = {
42866 (char *) "self",(char *) "font", NULL
42867 };
42868
42869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
42870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42871 if (!SWIG_IsOK(res1)) {
42872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42873 }
42874 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42875 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
42876 if (!SWIG_IsOK(res2)) {
42877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42878 }
42879 if (!argp2) {
42880 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42881 }
42882 arg2 = reinterpret_cast< wxFont * >(argp2);
42883 {
42884 PyThreadState* __tstate = wxPyBeginAllowThreads();
42885 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
42886 wxPyEndAllowThreads(__tstate);
42887 if (PyErr_Occurred()) SWIG_fail;
42888 }
42889 resultobj = SWIG_Py_Void();
42890 return resultobj;
42891 fail:
42892 return NULL;
42893 }
42894
42895
42896 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42897 PyObject *resultobj = 0;
42898 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42899 wxFont result;
42900 void *argp1 = 0 ;
42901 int res1 = 0 ;
42902 PyObject *swig_obj[1] ;
42903
42904 if (!args) SWIG_fail;
42905 swig_obj[0] = args;
42906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42907 if (!SWIG_IsOK(res1)) {
42908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42909 }
42910 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42911 {
42912 PyThreadState* __tstate = wxPyBeginAllowThreads();
42913 result = wxMenuItem_GetFont(arg1);
42914 wxPyEndAllowThreads(__tstate);
42915 if (PyErr_Occurred()) SWIG_fail;
42916 }
42917 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
42918 return resultobj;
42919 fail:
42920 return NULL;
42921 }
42922
42923
42924 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42925 PyObject *resultobj = 0;
42926 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42927 wxColour *arg2 = 0 ;
42928 void *argp1 = 0 ;
42929 int res1 = 0 ;
42930 wxColour temp2 ;
42931 PyObject * obj0 = 0 ;
42932 PyObject * obj1 = 0 ;
42933 char * kwnames[] = {
42934 (char *) "self",(char *) "colText", NULL
42935 };
42936
42937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
42938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42939 if (!SWIG_IsOK(res1)) {
42940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42941 }
42942 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42943 {
42944 arg2 = &temp2;
42945 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
42946 }
42947 {
42948 PyThreadState* __tstate = wxPyBeginAllowThreads();
42949 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
42950 wxPyEndAllowThreads(__tstate);
42951 if (PyErr_Occurred()) SWIG_fail;
42952 }
42953 resultobj = SWIG_Py_Void();
42954 return resultobj;
42955 fail:
42956 return NULL;
42957 }
42958
42959
42960 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42961 PyObject *resultobj = 0;
42962 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42963 wxColour result;
42964 void *argp1 = 0 ;
42965 int res1 = 0 ;
42966 PyObject *swig_obj[1] ;
42967
42968 if (!args) SWIG_fail;
42969 swig_obj[0] = args;
42970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42971 if (!SWIG_IsOK(res1)) {
42972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42973 }
42974 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42975 {
42976 PyThreadState* __tstate = wxPyBeginAllowThreads();
42977 result = wxMenuItem_GetTextColour(arg1);
42978 wxPyEndAllowThreads(__tstate);
42979 if (PyErr_Occurred()) SWIG_fail;
42980 }
42981 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
42982 return resultobj;
42983 fail:
42984 return NULL;
42985 }
42986
42987
42988 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42989 PyObject *resultobj = 0;
42990 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42991 wxColour *arg2 = 0 ;
42992 void *argp1 = 0 ;
42993 int res1 = 0 ;
42994 wxColour temp2 ;
42995 PyObject * obj0 = 0 ;
42996 PyObject * obj1 = 0 ;
42997 char * kwnames[] = {
42998 (char *) "self",(char *) "colBack", NULL
42999 };
43000
43001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43003 if (!SWIG_IsOK(res1)) {
43004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43005 }
43006 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43007 {
43008 arg2 = &temp2;
43009 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43010 }
43011 {
43012 PyThreadState* __tstate = wxPyBeginAllowThreads();
43013 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43014 wxPyEndAllowThreads(__tstate);
43015 if (PyErr_Occurred()) SWIG_fail;
43016 }
43017 resultobj = SWIG_Py_Void();
43018 return resultobj;
43019 fail:
43020 return NULL;
43021 }
43022
43023
43024 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43025 PyObject *resultobj = 0;
43026 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43027 wxColour result;
43028 void *argp1 = 0 ;
43029 int res1 = 0 ;
43030 PyObject *swig_obj[1] ;
43031
43032 if (!args) SWIG_fail;
43033 swig_obj[0] = args;
43034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43035 if (!SWIG_IsOK(res1)) {
43036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43037 }
43038 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43039 {
43040 PyThreadState* __tstate = wxPyBeginAllowThreads();
43041 result = wxMenuItem_GetBackgroundColour(arg1);
43042 wxPyEndAllowThreads(__tstate);
43043 if (PyErr_Occurred()) SWIG_fail;
43044 }
43045 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43046 return resultobj;
43047 fail:
43048 return NULL;
43049 }
43050
43051
43052 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43053 PyObject *resultobj = 0;
43054 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43055 wxBitmap *arg2 = 0 ;
43056 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43057 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43058 void *argp1 = 0 ;
43059 int res1 = 0 ;
43060 void *argp2 = 0 ;
43061 int res2 = 0 ;
43062 void *argp3 = 0 ;
43063 int res3 = 0 ;
43064 PyObject * obj0 = 0 ;
43065 PyObject * obj1 = 0 ;
43066 PyObject * obj2 = 0 ;
43067 char * kwnames[] = {
43068 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43069 };
43070
43071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43073 if (!SWIG_IsOK(res1)) {
43074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43075 }
43076 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43077 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43078 if (!SWIG_IsOK(res2)) {
43079 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43080 }
43081 if (!argp2) {
43082 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43083 }
43084 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43085 if (obj2) {
43086 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43087 if (!SWIG_IsOK(res3)) {
43088 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43089 }
43090 if (!argp3) {
43091 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43092 }
43093 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43094 }
43095 {
43096 PyThreadState* __tstate = wxPyBeginAllowThreads();
43097 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43098 wxPyEndAllowThreads(__tstate);
43099 if (PyErr_Occurred()) SWIG_fail;
43100 }
43101 resultobj = SWIG_Py_Void();
43102 return resultobj;
43103 fail:
43104 return NULL;
43105 }
43106
43107
43108 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43109 PyObject *resultobj = 0;
43110 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43111 wxBitmap *arg2 = 0 ;
43112 void *argp1 = 0 ;
43113 int res1 = 0 ;
43114 void *argp2 = 0 ;
43115 int res2 = 0 ;
43116 PyObject * obj0 = 0 ;
43117 PyObject * obj1 = 0 ;
43118 char * kwnames[] = {
43119 (char *) "self",(char *) "bmpDisabled", NULL
43120 };
43121
43122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43124 if (!SWIG_IsOK(res1)) {
43125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43126 }
43127 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43128 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43129 if (!SWIG_IsOK(res2)) {
43130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43131 }
43132 if (!argp2) {
43133 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43134 }
43135 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43136 {
43137 PyThreadState* __tstate = wxPyBeginAllowThreads();
43138 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43139 wxPyEndAllowThreads(__tstate);
43140 if (PyErr_Occurred()) SWIG_fail;
43141 }
43142 resultobj = SWIG_Py_Void();
43143 return resultobj;
43144 fail:
43145 return NULL;
43146 }
43147
43148
43149 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43150 PyObject *resultobj = 0;
43151 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43152 wxBitmap *result = 0 ;
43153 void *argp1 = 0 ;
43154 int res1 = 0 ;
43155 PyObject *swig_obj[1] ;
43156
43157 if (!args) SWIG_fail;
43158 swig_obj[0] = args;
43159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43160 if (!SWIG_IsOK(res1)) {
43161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43162 }
43163 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43164 {
43165 PyThreadState* __tstate = wxPyBeginAllowThreads();
43166 {
43167 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43168 result = (wxBitmap *) &_result_ref;
43169 }
43170 wxPyEndAllowThreads(__tstate);
43171 if (PyErr_Occurred()) SWIG_fail;
43172 }
43173 {
43174 wxBitmap* resultptr = new wxBitmap(*result);
43175 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43176 }
43177 return resultobj;
43178 fail:
43179 return NULL;
43180 }
43181
43182
43183 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43184 PyObject *resultobj = 0;
43185 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43186 int arg2 ;
43187 void *argp1 = 0 ;
43188 int res1 = 0 ;
43189 int val2 ;
43190 int ecode2 = 0 ;
43191 PyObject * obj0 = 0 ;
43192 PyObject * obj1 = 0 ;
43193 char * kwnames[] = {
43194 (char *) "self",(char *) "nWidth", NULL
43195 };
43196
43197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43199 if (!SWIG_IsOK(res1)) {
43200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43201 }
43202 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43203 ecode2 = SWIG_AsVal_int(obj1, &val2);
43204 if (!SWIG_IsOK(ecode2)) {
43205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43206 }
43207 arg2 = static_cast< int >(val2);
43208 {
43209 PyThreadState* __tstate = wxPyBeginAllowThreads();
43210 wxMenuItem_SetMarginWidth(arg1,arg2);
43211 wxPyEndAllowThreads(__tstate);
43212 if (PyErr_Occurred()) SWIG_fail;
43213 }
43214 resultobj = SWIG_Py_Void();
43215 return resultobj;
43216 fail:
43217 return NULL;
43218 }
43219
43220
43221 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43222 PyObject *resultobj = 0;
43223 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43224 int result;
43225 void *argp1 = 0 ;
43226 int res1 = 0 ;
43227 PyObject *swig_obj[1] ;
43228
43229 if (!args) SWIG_fail;
43230 swig_obj[0] = args;
43231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43232 if (!SWIG_IsOK(res1)) {
43233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43234 }
43235 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43236 {
43237 PyThreadState* __tstate = wxPyBeginAllowThreads();
43238 result = (int)wxMenuItem_GetMarginWidth(arg1);
43239 wxPyEndAllowThreads(__tstate);
43240 if (PyErr_Occurred()) SWIG_fail;
43241 }
43242 resultobj = SWIG_From_int(static_cast< int >(result));
43243 return resultobj;
43244 fail:
43245 return NULL;
43246 }
43247
43248
43249 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43250 PyObject *resultobj = 0;
43251 int result;
43252
43253 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43254 {
43255 PyThreadState* __tstate = wxPyBeginAllowThreads();
43256 result = (int)wxMenuItem_GetDefaultMarginWidth();
43257 wxPyEndAllowThreads(__tstate);
43258 if (PyErr_Occurred()) SWIG_fail;
43259 }
43260 resultobj = SWIG_From_int(static_cast< int >(result));
43261 return resultobj;
43262 fail:
43263 return NULL;
43264 }
43265
43266
43267 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43268 PyObject *resultobj = 0;
43269 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43270 bool result;
43271 void *argp1 = 0 ;
43272 int res1 = 0 ;
43273 PyObject *swig_obj[1] ;
43274
43275 if (!args) SWIG_fail;
43276 swig_obj[0] = args;
43277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43278 if (!SWIG_IsOK(res1)) {
43279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43280 }
43281 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43282 {
43283 PyThreadState* __tstate = wxPyBeginAllowThreads();
43284 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43285 wxPyEndAllowThreads(__tstate);
43286 if (PyErr_Occurred()) SWIG_fail;
43287 }
43288 {
43289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43290 }
43291 return resultobj;
43292 fail:
43293 return NULL;
43294 }
43295
43296
43297 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43298 PyObject *resultobj = 0;
43299 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43300 bool arg2 = (bool) true ;
43301 void *argp1 = 0 ;
43302 int res1 = 0 ;
43303 bool val2 ;
43304 int ecode2 = 0 ;
43305 PyObject * obj0 = 0 ;
43306 PyObject * obj1 = 0 ;
43307 char * kwnames[] = {
43308 (char *) "self",(char *) "ownerDrawn", NULL
43309 };
43310
43311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43313 if (!SWIG_IsOK(res1)) {
43314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43315 }
43316 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43317 if (obj1) {
43318 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43319 if (!SWIG_IsOK(ecode2)) {
43320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43321 }
43322 arg2 = static_cast< bool >(val2);
43323 }
43324 {
43325 PyThreadState* __tstate = wxPyBeginAllowThreads();
43326 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43327 wxPyEndAllowThreads(__tstate);
43328 if (PyErr_Occurred()) SWIG_fail;
43329 }
43330 resultobj = SWIG_Py_Void();
43331 return resultobj;
43332 fail:
43333 return NULL;
43334 }
43335
43336
43337 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43338 PyObject *resultobj = 0;
43339 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43340 void *argp1 = 0 ;
43341 int res1 = 0 ;
43342 PyObject *swig_obj[1] ;
43343
43344 if (!args) SWIG_fail;
43345 swig_obj[0] = args;
43346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43347 if (!SWIG_IsOK(res1)) {
43348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43349 }
43350 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43351 {
43352 PyThreadState* __tstate = wxPyBeginAllowThreads();
43353 wxMenuItem_ResetOwnerDrawn(arg1);
43354 wxPyEndAllowThreads(__tstate);
43355 if (PyErr_Occurred()) SWIG_fail;
43356 }
43357 resultobj = SWIG_Py_Void();
43358 return resultobj;
43359 fail:
43360 return NULL;
43361 }
43362
43363
43364 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43365 PyObject *obj;
43366 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43367 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43368 return SWIG_Py_Void();
43369 }
43370
43371 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43372 return SWIG_Python_InitShadowInstance(args);
43373 }
43374
43375 SWIGINTERN int ControlNameStr_set(PyObject *) {
43376 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43377 return 1;
43378 }
43379
43380
43381 SWIGINTERN PyObject *ControlNameStr_get(void) {
43382 PyObject *pyobj = 0;
43383
43384 {
43385 #if wxUSE_UNICODE
43386 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43387 #else
43388 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43389 #endif
43390 }
43391 return pyobj;
43392 }
43393
43394
43395 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43396 PyObject *resultobj = 0;
43397 wxWindow *arg1 = (wxWindow *) 0 ;
43398 int arg2 = (int) -1 ;
43399 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43400 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43401 wxSize const &arg4_defvalue = wxDefaultSize ;
43402 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43403 long arg5 = (long) 0 ;
43404 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43405 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43406 wxString const &arg7_defvalue = wxPyControlNameStr ;
43407 wxString *arg7 = (wxString *) &arg7_defvalue ;
43408 wxControl *result = 0 ;
43409 void *argp1 = 0 ;
43410 int res1 = 0 ;
43411 int val2 ;
43412 int ecode2 = 0 ;
43413 wxPoint temp3 ;
43414 wxSize temp4 ;
43415 long val5 ;
43416 int ecode5 = 0 ;
43417 void *argp6 = 0 ;
43418 int res6 = 0 ;
43419 bool temp7 = false ;
43420 PyObject * obj0 = 0 ;
43421 PyObject * obj1 = 0 ;
43422 PyObject * obj2 = 0 ;
43423 PyObject * obj3 = 0 ;
43424 PyObject * obj4 = 0 ;
43425 PyObject * obj5 = 0 ;
43426 PyObject * obj6 = 0 ;
43427 char * kwnames[] = {
43428 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43429 };
43430
43431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43433 if (!SWIG_IsOK(res1)) {
43434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43435 }
43436 arg1 = reinterpret_cast< wxWindow * >(argp1);
43437 if (obj1) {
43438 ecode2 = SWIG_AsVal_int(obj1, &val2);
43439 if (!SWIG_IsOK(ecode2)) {
43440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43441 }
43442 arg2 = static_cast< int >(val2);
43443 }
43444 if (obj2) {
43445 {
43446 arg3 = &temp3;
43447 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43448 }
43449 }
43450 if (obj3) {
43451 {
43452 arg4 = &temp4;
43453 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43454 }
43455 }
43456 if (obj4) {
43457 ecode5 = SWIG_AsVal_long(obj4, &val5);
43458 if (!SWIG_IsOK(ecode5)) {
43459 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43460 }
43461 arg5 = static_cast< long >(val5);
43462 }
43463 if (obj5) {
43464 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43465 if (!SWIG_IsOK(res6)) {
43466 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43467 }
43468 if (!argp6) {
43469 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43470 }
43471 arg6 = reinterpret_cast< wxValidator * >(argp6);
43472 }
43473 if (obj6) {
43474 {
43475 arg7 = wxString_in_helper(obj6);
43476 if (arg7 == NULL) SWIG_fail;
43477 temp7 = true;
43478 }
43479 }
43480 {
43481 if (!wxPyCheckForApp()) SWIG_fail;
43482 PyThreadState* __tstate = wxPyBeginAllowThreads();
43483 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43484 wxPyEndAllowThreads(__tstate);
43485 if (PyErr_Occurred()) SWIG_fail;
43486 }
43487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43488 {
43489 if (temp7)
43490 delete arg7;
43491 }
43492 return resultobj;
43493 fail:
43494 {
43495 if (temp7)
43496 delete arg7;
43497 }
43498 return NULL;
43499 }
43500
43501
43502 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43503 PyObject *resultobj = 0;
43504 wxControl *result = 0 ;
43505
43506 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43507 {
43508 if (!wxPyCheckForApp()) SWIG_fail;
43509 PyThreadState* __tstate = wxPyBeginAllowThreads();
43510 result = (wxControl *)new wxControl();
43511 wxPyEndAllowThreads(__tstate);
43512 if (PyErr_Occurred()) SWIG_fail;
43513 }
43514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43515 return resultobj;
43516 fail:
43517 return NULL;
43518 }
43519
43520
43521 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43522 PyObject *resultobj = 0;
43523 wxControl *arg1 = (wxControl *) 0 ;
43524 wxWindow *arg2 = (wxWindow *) 0 ;
43525 int arg3 = (int) -1 ;
43526 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43527 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43528 wxSize const &arg5_defvalue = wxDefaultSize ;
43529 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43530 long arg6 = (long) 0 ;
43531 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43532 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43533 wxString const &arg8_defvalue = wxPyControlNameStr ;
43534 wxString *arg8 = (wxString *) &arg8_defvalue ;
43535 bool result;
43536 void *argp1 = 0 ;
43537 int res1 = 0 ;
43538 void *argp2 = 0 ;
43539 int res2 = 0 ;
43540 int val3 ;
43541 int ecode3 = 0 ;
43542 wxPoint temp4 ;
43543 wxSize temp5 ;
43544 long val6 ;
43545 int ecode6 = 0 ;
43546 void *argp7 = 0 ;
43547 int res7 = 0 ;
43548 bool temp8 = false ;
43549 PyObject * obj0 = 0 ;
43550 PyObject * obj1 = 0 ;
43551 PyObject * obj2 = 0 ;
43552 PyObject * obj3 = 0 ;
43553 PyObject * obj4 = 0 ;
43554 PyObject * obj5 = 0 ;
43555 PyObject * obj6 = 0 ;
43556 PyObject * obj7 = 0 ;
43557 char * kwnames[] = {
43558 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43559 };
43560
43561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43563 if (!SWIG_IsOK(res1)) {
43564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43565 }
43566 arg1 = reinterpret_cast< wxControl * >(argp1);
43567 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43568 if (!SWIG_IsOK(res2)) {
43569 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43570 }
43571 arg2 = reinterpret_cast< wxWindow * >(argp2);
43572 if (obj2) {
43573 ecode3 = SWIG_AsVal_int(obj2, &val3);
43574 if (!SWIG_IsOK(ecode3)) {
43575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43576 }
43577 arg3 = static_cast< int >(val3);
43578 }
43579 if (obj3) {
43580 {
43581 arg4 = &temp4;
43582 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43583 }
43584 }
43585 if (obj4) {
43586 {
43587 arg5 = &temp5;
43588 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43589 }
43590 }
43591 if (obj5) {
43592 ecode6 = SWIG_AsVal_long(obj5, &val6);
43593 if (!SWIG_IsOK(ecode6)) {
43594 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43595 }
43596 arg6 = static_cast< long >(val6);
43597 }
43598 if (obj6) {
43599 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43600 if (!SWIG_IsOK(res7)) {
43601 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43602 }
43603 if (!argp7) {
43604 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43605 }
43606 arg7 = reinterpret_cast< wxValidator * >(argp7);
43607 }
43608 if (obj7) {
43609 {
43610 arg8 = wxString_in_helper(obj7);
43611 if (arg8 == NULL) SWIG_fail;
43612 temp8 = true;
43613 }
43614 }
43615 {
43616 PyThreadState* __tstate = wxPyBeginAllowThreads();
43617 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43618 wxPyEndAllowThreads(__tstate);
43619 if (PyErr_Occurred()) SWIG_fail;
43620 }
43621 {
43622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43623 }
43624 {
43625 if (temp8)
43626 delete arg8;
43627 }
43628 return resultobj;
43629 fail:
43630 {
43631 if (temp8)
43632 delete arg8;
43633 }
43634 return NULL;
43635 }
43636
43637
43638 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43639 PyObject *resultobj = 0;
43640 wxControl *arg1 = (wxControl *) 0 ;
43641 wxCommandEvent *arg2 = 0 ;
43642 void *argp1 = 0 ;
43643 int res1 = 0 ;
43644 void *argp2 = 0 ;
43645 int res2 = 0 ;
43646 PyObject * obj0 = 0 ;
43647 PyObject * obj1 = 0 ;
43648 char * kwnames[] = {
43649 (char *) "self",(char *) "event", NULL
43650 };
43651
43652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43654 if (!SWIG_IsOK(res1)) {
43655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43656 }
43657 arg1 = reinterpret_cast< wxControl * >(argp1);
43658 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43659 if (!SWIG_IsOK(res2)) {
43660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43661 }
43662 if (!argp2) {
43663 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43664 }
43665 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43666 {
43667 PyThreadState* __tstate = wxPyBeginAllowThreads();
43668 (arg1)->Command(*arg2);
43669 wxPyEndAllowThreads(__tstate);
43670 if (PyErr_Occurred()) SWIG_fail;
43671 }
43672 resultobj = SWIG_Py_Void();
43673 return resultobj;
43674 fail:
43675 return NULL;
43676 }
43677
43678
43679 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43680 PyObject *resultobj = 0;
43681 wxControl *arg1 = (wxControl *) 0 ;
43682 wxString result;
43683 void *argp1 = 0 ;
43684 int res1 = 0 ;
43685 PyObject *swig_obj[1] ;
43686
43687 if (!args) SWIG_fail;
43688 swig_obj[0] = args;
43689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43690 if (!SWIG_IsOK(res1)) {
43691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43692 }
43693 arg1 = reinterpret_cast< wxControl * >(argp1);
43694 {
43695 PyThreadState* __tstate = wxPyBeginAllowThreads();
43696 result = (arg1)->GetLabel();
43697 wxPyEndAllowThreads(__tstate);
43698 if (PyErr_Occurred()) SWIG_fail;
43699 }
43700 {
43701 #if wxUSE_UNICODE
43702 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43703 #else
43704 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43705 #endif
43706 }
43707 return resultobj;
43708 fail:
43709 return NULL;
43710 }
43711
43712
43713 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43714 PyObject *resultobj = 0;
43715 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43716 SwigValueWrapper<wxVisualAttributes > result;
43717 int val1 ;
43718 int ecode1 = 0 ;
43719 PyObject * obj0 = 0 ;
43720 char * kwnames[] = {
43721 (char *) "variant", NULL
43722 };
43723
43724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43725 if (obj0) {
43726 ecode1 = SWIG_AsVal_int(obj0, &val1);
43727 if (!SWIG_IsOK(ecode1)) {
43728 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43729 }
43730 arg1 = static_cast< wxWindowVariant >(val1);
43731 }
43732 {
43733 if (!wxPyCheckForApp()) SWIG_fail;
43734 PyThreadState* __tstate = wxPyBeginAllowThreads();
43735 result = wxControl::GetClassDefaultAttributes(arg1);
43736 wxPyEndAllowThreads(__tstate);
43737 if (PyErr_Occurred()) SWIG_fail;
43738 }
43739 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
43740 return resultobj;
43741 fail:
43742 return NULL;
43743 }
43744
43745
43746 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43747 PyObject *obj;
43748 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43749 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
43750 return SWIG_Py_Void();
43751 }
43752
43753 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43754 return SWIG_Python_InitShadowInstance(args);
43755 }
43756
43757 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43758 PyObject *resultobj = 0;
43759 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43760 wxString *arg2 = 0 ;
43761 PyObject *arg3 = (PyObject *) NULL ;
43762 int result;
43763 void *argp1 = 0 ;
43764 int res1 = 0 ;
43765 bool temp2 = false ;
43766 PyObject * obj0 = 0 ;
43767 PyObject * obj1 = 0 ;
43768 PyObject * obj2 = 0 ;
43769 char * kwnames[] = {
43770 (char *) "self",(char *) "item",(char *) "clientData", NULL
43771 };
43772
43773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43775 if (!SWIG_IsOK(res1)) {
43776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43777 }
43778 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43779 {
43780 arg2 = wxString_in_helper(obj1);
43781 if (arg2 == NULL) SWIG_fail;
43782 temp2 = true;
43783 }
43784 if (obj2) {
43785 arg3 = obj2;
43786 }
43787 {
43788 PyThreadState* __tstate = wxPyBeginAllowThreads();
43789 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
43790 wxPyEndAllowThreads(__tstate);
43791 if (PyErr_Occurred()) SWIG_fail;
43792 }
43793 resultobj = SWIG_From_int(static_cast< int >(result));
43794 {
43795 if (temp2)
43796 delete arg2;
43797 }
43798 return resultobj;
43799 fail:
43800 {
43801 if (temp2)
43802 delete arg2;
43803 }
43804 return NULL;
43805 }
43806
43807
43808 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43809 PyObject *resultobj = 0;
43810 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43811 wxArrayString *arg2 = 0 ;
43812 void *argp1 = 0 ;
43813 int res1 = 0 ;
43814 bool temp2 = false ;
43815 PyObject * obj0 = 0 ;
43816 PyObject * obj1 = 0 ;
43817 char * kwnames[] = {
43818 (char *) "self",(char *) "strings", NULL
43819 };
43820
43821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
43822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43823 if (!SWIG_IsOK(res1)) {
43824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43825 }
43826 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43827 {
43828 if (! PySequence_Check(obj1)) {
43829 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
43830 SWIG_fail;
43831 }
43832 arg2 = new wxArrayString;
43833 temp2 = true;
43834 int i, len=PySequence_Length(obj1);
43835 for (i=0; i<len; i++) {
43836 PyObject* item = PySequence_GetItem(obj1, i);
43837 wxString* s = wxString_in_helper(item);
43838 if (PyErr_Occurred()) SWIG_fail;
43839 arg2->Add(*s);
43840 delete s;
43841 Py_DECREF(item);
43842 }
43843 }
43844 {
43845 PyThreadState* __tstate = wxPyBeginAllowThreads();
43846 (arg1)->Append((wxArrayString const &)*arg2);
43847 wxPyEndAllowThreads(__tstate);
43848 if (PyErr_Occurred()) SWIG_fail;
43849 }
43850 resultobj = SWIG_Py_Void();
43851 {
43852 if (temp2) delete arg2;
43853 }
43854 return resultobj;
43855 fail:
43856 {
43857 if (temp2) delete arg2;
43858 }
43859 return NULL;
43860 }
43861
43862
43863 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43864 PyObject *resultobj = 0;
43865 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43866 wxString *arg2 = 0 ;
43867 int arg3 ;
43868 PyObject *arg4 = (PyObject *) NULL ;
43869 int result;
43870 void *argp1 = 0 ;
43871 int res1 = 0 ;
43872 bool temp2 = false ;
43873 int val3 ;
43874 int ecode3 = 0 ;
43875 PyObject * obj0 = 0 ;
43876 PyObject * obj1 = 0 ;
43877 PyObject * obj2 = 0 ;
43878 PyObject * obj3 = 0 ;
43879 char * kwnames[] = {
43880 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
43881 };
43882
43883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43885 if (!SWIG_IsOK(res1)) {
43886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43887 }
43888 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43889 {
43890 arg2 = wxString_in_helper(obj1);
43891 if (arg2 == NULL) SWIG_fail;
43892 temp2 = true;
43893 }
43894 ecode3 = SWIG_AsVal_int(obj2, &val3);
43895 if (!SWIG_IsOK(ecode3)) {
43896 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
43897 }
43898 arg3 = static_cast< int >(val3);
43899 if (obj3) {
43900 arg4 = obj3;
43901 }
43902 {
43903 PyThreadState* __tstate = wxPyBeginAllowThreads();
43904 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
43905 wxPyEndAllowThreads(__tstate);
43906 if (PyErr_Occurred()) SWIG_fail;
43907 }
43908 resultobj = SWIG_From_int(static_cast< int >(result));
43909 {
43910 if (temp2)
43911 delete arg2;
43912 }
43913 return resultobj;
43914 fail:
43915 {
43916 if (temp2)
43917 delete arg2;
43918 }
43919 return NULL;
43920 }
43921
43922
43923 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43924 PyObject *resultobj = 0;
43925 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43926 void *argp1 = 0 ;
43927 int res1 = 0 ;
43928 PyObject *swig_obj[1] ;
43929
43930 if (!args) SWIG_fail;
43931 swig_obj[0] = args;
43932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43933 if (!SWIG_IsOK(res1)) {
43934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43935 }
43936 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43937 {
43938 PyThreadState* __tstate = wxPyBeginAllowThreads();
43939 (arg1)->Clear();
43940 wxPyEndAllowThreads(__tstate);
43941 if (PyErr_Occurred()) SWIG_fail;
43942 }
43943 resultobj = SWIG_Py_Void();
43944 return resultobj;
43945 fail:
43946 return NULL;
43947 }
43948
43949
43950 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43951 PyObject *resultobj = 0;
43952 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43953 int arg2 ;
43954 void *argp1 = 0 ;
43955 int res1 = 0 ;
43956 int val2 ;
43957 int ecode2 = 0 ;
43958 PyObject * obj0 = 0 ;
43959 PyObject * obj1 = 0 ;
43960 char * kwnames[] = {
43961 (char *) "self",(char *) "n", NULL
43962 };
43963
43964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43966 if (!SWIG_IsOK(res1)) {
43967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43968 }
43969 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43970 ecode2 = SWIG_AsVal_int(obj1, &val2);
43971 if (!SWIG_IsOK(ecode2)) {
43972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
43973 }
43974 arg2 = static_cast< int >(val2);
43975 {
43976 PyThreadState* __tstate = wxPyBeginAllowThreads();
43977 (arg1)->Delete(arg2);
43978 wxPyEndAllowThreads(__tstate);
43979 if (PyErr_Occurred()) SWIG_fail;
43980 }
43981 resultobj = SWIG_Py_Void();
43982 return resultobj;
43983 fail:
43984 return NULL;
43985 }
43986
43987
43988 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43989 PyObject *resultobj = 0;
43990 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43991 int arg2 ;
43992 PyObject *result = 0 ;
43993 void *argp1 = 0 ;
43994 int res1 = 0 ;
43995 int val2 ;
43996 int ecode2 = 0 ;
43997 PyObject * obj0 = 0 ;
43998 PyObject * obj1 = 0 ;
43999 char * kwnames[] = {
44000 (char *) "self",(char *) "n", NULL
44001 };
44002
44003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44005 if (!SWIG_IsOK(res1)) {
44006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44007 }
44008 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44009 ecode2 = SWIG_AsVal_int(obj1, &val2);
44010 if (!SWIG_IsOK(ecode2)) {
44011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
44012 }
44013 arg2 = static_cast< int >(val2);
44014 {
44015 PyThreadState* __tstate = wxPyBeginAllowThreads();
44016 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44017 wxPyEndAllowThreads(__tstate);
44018 if (PyErr_Occurred()) SWIG_fail;
44019 }
44020 resultobj = result;
44021 return resultobj;
44022 fail:
44023 return NULL;
44024 }
44025
44026
44027 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44028 PyObject *resultobj = 0;
44029 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44030 int arg2 ;
44031 PyObject *arg3 = (PyObject *) 0 ;
44032 void *argp1 = 0 ;
44033 int res1 = 0 ;
44034 int val2 ;
44035 int ecode2 = 0 ;
44036 PyObject * obj0 = 0 ;
44037 PyObject * obj1 = 0 ;
44038 PyObject * obj2 = 0 ;
44039 char * kwnames[] = {
44040 (char *) "self",(char *) "n",(char *) "clientData", NULL
44041 };
44042
44043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44045 if (!SWIG_IsOK(res1)) {
44046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44047 }
44048 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44049 ecode2 = SWIG_AsVal_int(obj1, &val2);
44050 if (!SWIG_IsOK(ecode2)) {
44051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
44052 }
44053 arg2 = static_cast< int >(val2);
44054 arg3 = obj2;
44055 {
44056 PyThreadState* __tstate = wxPyBeginAllowThreads();
44057 wxItemContainer_SetClientData(arg1,arg2,arg3);
44058 wxPyEndAllowThreads(__tstate);
44059 if (PyErr_Occurred()) SWIG_fail;
44060 }
44061 resultobj = SWIG_Py_Void();
44062 return resultobj;
44063 fail:
44064 return NULL;
44065 }
44066
44067
44068 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44069 PyObject *resultobj = 0;
44070 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44071 size_t result;
44072 void *argp1 = 0 ;
44073 int res1 = 0 ;
44074 PyObject *swig_obj[1] ;
44075
44076 if (!args) SWIG_fail;
44077 swig_obj[0] = args;
44078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44079 if (!SWIG_IsOK(res1)) {
44080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44081 }
44082 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44083 {
44084 PyThreadState* __tstate = wxPyBeginAllowThreads();
44085 result = (size_t)((wxItemContainer const *)arg1)->GetCount();
44086 wxPyEndAllowThreads(__tstate);
44087 if (PyErr_Occurred()) SWIG_fail;
44088 }
44089 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44090 return resultobj;
44091 fail:
44092 return NULL;
44093 }
44094
44095
44096 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44097 PyObject *resultobj = 0;
44098 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44099 bool result;
44100 void *argp1 = 0 ;
44101 int res1 = 0 ;
44102 PyObject *swig_obj[1] ;
44103
44104 if (!args) SWIG_fail;
44105 swig_obj[0] = args;
44106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44107 if (!SWIG_IsOK(res1)) {
44108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44109 }
44110 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44111 {
44112 PyThreadState* __tstate = wxPyBeginAllowThreads();
44113 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44114 wxPyEndAllowThreads(__tstate);
44115 if (PyErr_Occurred()) SWIG_fail;
44116 }
44117 {
44118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44119 }
44120 return resultobj;
44121 fail:
44122 return NULL;
44123 }
44124
44125
44126 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44127 PyObject *resultobj = 0;
44128 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44129 int arg2 ;
44130 wxString result;
44131 void *argp1 = 0 ;
44132 int res1 = 0 ;
44133 int val2 ;
44134 int ecode2 = 0 ;
44135 PyObject * obj0 = 0 ;
44136 PyObject * obj1 = 0 ;
44137 char * kwnames[] = {
44138 (char *) "self",(char *) "n", NULL
44139 };
44140
44141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44143 if (!SWIG_IsOK(res1)) {
44144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44145 }
44146 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44147 ecode2 = SWIG_AsVal_int(obj1, &val2);
44148 if (!SWIG_IsOK(ecode2)) {
44149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
44150 }
44151 arg2 = static_cast< int >(val2);
44152 {
44153 PyThreadState* __tstate = wxPyBeginAllowThreads();
44154 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44155 wxPyEndAllowThreads(__tstate);
44156 if (PyErr_Occurred()) SWIG_fail;
44157 }
44158 {
44159 #if wxUSE_UNICODE
44160 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44161 #else
44162 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44163 #endif
44164 }
44165 return resultobj;
44166 fail:
44167 return NULL;
44168 }
44169
44170
44171 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44172 PyObject *resultobj = 0;
44173 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44174 wxArrayString result;
44175 void *argp1 = 0 ;
44176 int res1 = 0 ;
44177 PyObject *swig_obj[1] ;
44178
44179 if (!args) SWIG_fail;
44180 swig_obj[0] = args;
44181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44182 if (!SWIG_IsOK(res1)) {
44183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44184 }
44185 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44186 {
44187 PyThreadState* __tstate = wxPyBeginAllowThreads();
44188 result = ((wxItemContainer const *)arg1)->GetStrings();
44189 wxPyEndAllowThreads(__tstate);
44190 if (PyErr_Occurred()) SWIG_fail;
44191 }
44192 {
44193 resultobj = wxArrayString2PyList_helper(result);
44194 }
44195 return resultobj;
44196 fail:
44197 return NULL;
44198 }
44199
44200
44201 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44202 PyObject *resultobj = 0;
44203 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44204 int arg2 ;
44205 wxString *arg3 = 0 ;
44206 void *argp1 = 0 ;
44207 int res1 = 0 ;
44208 int val2 ;
44209 int ecode2 = 0 ;
44210 bool temp3 = false ;
44211 PyObject * obj0 = 0 ;
44212 PyObject * obj1 = 0 ;
44213 PyObject * obj2 = 0 ;
44214 char * kwnames[] = {
44215 (char *) "self",(char *) "n",(char *) "s", NULL
44216 };
44217
44218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44220 if (!SWIG_IsOK(res1)) {
44221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44222 }
44223 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44224 ecode2 = SWIG_AsVal_int(obj1, &val2);
44225 if (!SWIG_IsOK(ecode2)) {
44226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
44227 }
44228 arg2 = static_cast< int >(val2);
44229 {
44230 arg3 = wxString_in_helper(obj2);
44231 if (arg3 == NULL) SWIG_fail;
44232 temp3 = true;
44233 }
44234 {
44235 PyThreadState* __tstate = wxPyBeginAllowThreads();
44236 (arg1)->SetString(arg2,(wxString const &)*arg3);
44237 wxPyEndAllowThreads(__tstate);
44238 if (PyErr_Occurred()) SWIG_fail;
44239 }
44240 resultobj = SWIG_Py_Void();
44241 {
44242 if (temp3)
44243 delete arg3;
44244 }
44245 return resultobj;
44246 fail:
44247 {
44248 if (temp3)
44249 delete arg3;
44250 }
44251 return NULL;
44252 }
44253
44254
44255 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44256 PyObject *resultobj = 0;
44257 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44258 wxString *arg2 = 0 ;
44259 int result;
44260 void *argp1 = 0 ;
44261 int res1 = 0 ;
44262 bool temp2 = false ;
44263 PyObject * obj0 = 0 ;
44264 PyObject * obj1 = 0 ;
44265 char * kwnames[] = {
44266 (char *) "self",(char *) "s", NULL
44267 };
44268
44269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44271 if (!SWIG_IsOK(res1)) {
44272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44273 }
44274 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44275 {
44276 arg2 = wxString_in_helper(obj1);
44277 if (arg2 == NULL) SWIG_fail;
44278 temp2 = true;
44279 }
44280 {
44281 PyThreadState* __tstate = wxPyBeginAllowThreads();
44282 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44283 wxPyEndAllowThreads(__tstate);
44284 if (PyErr_Occurred()) SWIG_fail;
44285 }
44286 resultobj = SWIG_From_int(static_cast< int >(result));
44287 {
44288 if (temp2)
44289 delete arg2;
44290 }
44291 return resultobj;
44292 fail:
44293 {
44294 if (temp2)
44295 delete arg2;
44296 }
44297 return NULL;
44298 }
44299
44300
44301 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44302 PyObject *resultobj = 0;
44303 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44304 int arg2 ;
44305 void *argp1 = 0 ;
44306 int res1 = 0 ;
44307 int val2 ;
44308 int ecode2 = 0 ;
44309 PyObject * obj0 = 0 ;
44310 PyObject * obj1 = 0 ;
44311 char * kwnames[] = {
44312 (char *) "self",(char *) "n", NULL
44313 };
44314
44315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44317 if (!SWIG_IsOK(res1)) {
44318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44319 }
44320 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44321 ecode2 = SWIG_AsVal_int(obj1, &val2);
44322 if (!SWIG_IsOK(ecode2)) {
44323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44324 }
44325 arg2 = static_cast< int >(val2);
44326 {
44327 PyThreadState* __tstate = wxPyBeginAllowThreads();
44328 (arg1)->SetSelection(arg2);
44329 wxPyEndAllowThreads(__tstate);
44330 if (PyErr_Occurred()) SWIG_fail;
44331 }
44332 resultobj = SWIG_Py_Void();
44333 return resultobj;
44334 fail:
44335 return NULL;
44336 }
44337
44338
44339 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44340 PyObject *resultobj = 0;
44341 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44342 int result;
44343 void *argp1 = 0 ;
44344 int res1 = 0 ;
44345 PyObject *swig_obj[1] ;
44346
44347 if (!args) SWIG_fail;
44348 swig_obj[0] = args;
44349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44350 if (!SWIG_IsOK(res1)) {
44351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44352 }
44353 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44354 {
44355 PyThreadState* __tstate = wxPyBeginAllowThreads();
44356 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44357 wxPyEndAllowThreads(__tstate);
44358 if (PyErr_Occurred()) SWIG_fail;
44359 }
44360 resultobj = SWIG_From_int(static_cast< int >(result));
44361 return resultobj;
44362 fail:
44363 return NULL;
44364 }
44365
44366
44367 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44368 PyObject *resultobj = 0;
44369 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44370 wxString *arg2 = 0 ;
44371 bool result;
44372 void *argp1 = 0 ;
44373 int res1 = 0 ;
44374 bool temp2 = false ;
44375 PyObject * obj0 = 0 ;
44376 PyObject * obj1 = 0 ;
44377 char * kwnames[] = {
44378 (char *) "self",(char *) "s", NULL
44379 };
44380
44381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44383 if (!SWIG_IsOK(res1)) {
44384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44385 }
44386 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44387 {
44388 arg2 = wxString_in_helper(obj1);
44389 if (arg2 == NULL) SWIG_fail;
44390 temp2 = true;
44391 }
44392 {
44393 PyThreadState* __tstate = wxPyBeginAllowThreads();
44394 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44395 wxPyEndAllowThreads(__tstate);
44396 if (PyErr_Occurred()) SWIG_fail;
44397 }
44398 {
44399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44400 }
44401 {
44402 if (temp2)
44403 delete arg2;
44404 }
44405 return resultobj;
44406 fail:
44407 {
44408 if (temp2)
44409 delete arg2;
44410 }
44411 return NULL;
44412 }
44413
44414
44415 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44416 PyObject *resultobj = 0;
44417 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44418 wxString result;
44419 void *argp1 = 0 ;
44420 int res1 = 0 ;
44421 PyObject *swig_obj[1] ;
44422
44423 if (!args) SWIG_fail;
44424 swig_obj[0] = args;
44425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44426 if (!SWIG_IsOK(res1)) {
44427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44428 }
44429 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44430 {
44431 PyThreadState* __tstate = wxPyBeginAllowThreads();
44432 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44433 wxPyEndAllowThreads(__tstate);
44434 if (PyErr_Occurred()) SWIG_fail;
44435 }
44436 {
44437 #if wxUSE_UNICODE
44438 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44439 #else
44440 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44441 #endif
44442 }
44443 return resultobj;
44444 fail:
44445 return NULL;
44446 }
44447
44448
44449 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44450 PyObject *resultobj = 0;
44451 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44452 int arg2 ;
44453 void *argp1 = 0 ;
44454 int res1 = 0 ;
44455 int val2 ;
44456 int ecode2 = 0 ;
44457 PyObject * obj0 = 0 ;
44458 PyObject * obj1 = 0 ;
44459 char * kwnames[] = {
44460 (char *) "self",(char *) "n", NULL
44461 };
44462
44463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44465 if (!SWIG_IsOK(res1)) {
44466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44467 }
44468 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44469 ecode2 = SWIG_AsVal_int(obj1, &val2);
44470 if (!SWIG_IsOK(ecode2)) {
44471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44472 }
44473 arg2 = static_cast< int >(val2);
44474 {
44475 PyThreadState* __tstate = wxPyBeginAllowThreads();
44476 (arg1)->Select(arg2);
44477 wxPyEndAllowThreads(__tstate);
44478 if (PyErr_Occurred()) SWIG_fail;
44479 }
44480 resultobj = SWIG_Py_Void();
44481 return resultobj;
44482 fail:
44483 return NULL;
44484 }
44485
44486
44487 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44488 PyObject *obj;
44489 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44490 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44491 return SWIG_Py_Void();
44492 }
44493
44494 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44495 PyObject *obj;
44496 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44497 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44498 return SWIG_Py_Void();
44499 }
44500
44501 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44502 PyObject *resultobj = 0;
44503 wxSizerItem *result = 0 ;
44504
44505 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44506 {
44507 PyThreadState* __tstate = wxPyBeginAllowThreads();
44508 result = (wxSizerItem *)new wxSizerItem();
44509 wxPyEndAllowThreads(__tstate);
44510 if (PyErr_Occurred()) SWIG_fail;
44511 }
44512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44513 return resultobj;
44514 fail:
44515 return NULL;
44516 }
44517
44518
44519 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44520 PyObject *resultobj = 0;
44521 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44522 void *argp1 = 0 ;
44523 int res1 = 0 ;
44524 PyObject *swig_obj[1] ;
44525
44526 if (!args) SWIG_fail;
44527 swig_obj[0] = args;
44528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44529 if (!SWIG_IsOK(res1)) {
44530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44531 }
44532 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44533 {
44534 PyThreadState* __tstate = wxPyBeginAllowThreads();
44535 delete arg1;
44536
44537 wxPyEndAllowThreads(__tstate);
44538 if (PyErr_Occurred()) SWIG_fail;
44539 }
44540 resultobj = SWIG_Py_Void();
44541 return resultobj;
44542 fail:
44543 return NULL;
44544 }
44545
44546
44547 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44548 PyObject *resultobj = 0;
44549 wxWindow *arg1 = (wxWindow *) 0 ;
44550 int arg2 ;
44551 int arg3 ;
44552 int arg4 ;
44553 PyObject *arg5 = (PyObject *) NULL ;
44554 wxSizerItem *result = 0 ;
44555 void *argp1 = 0 ;
44556 int res1 = 0 ;
44557 int val2 ;
44558 int ecode2 = 0 ;
44559 int val3 ;
44560 int ecode3 = 0 ;
44561 int val4 ;
44562 int ecode4 = 0 ;
44563 PyObject * obj0 = 0 ;
44564 PyObject * obj1 = 0 ;
44565 PyObject * obj2 = 0 ;
44566 PyObject * obj3 = 0 ;
44567 PyObject * obj4 = 0 ;
44568 char * kwnames[] = {
44569 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44570 };
44571
44572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44574 if (!SWIG_IsOK(res1)) {
44575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44576 }
44577 arg1 = reinterpret_cast< wxWindow * >(argp1);
44578 ecode2 = SWIG_AsVal_int(obj1, &val2);
44579 if (!SWIG_IsOK(ecode2)) {
44580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44581 }
44582 arg2 = static_cast< int >(val2);
44583 ecode3 = SWIG_AsVal_int(obj2, &val3);
44584 if (!SWIG_IsOK(ecode3)) {
44585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44586 }
44587 arg3 = static_cast< int >(val3);
44588 ecode4 = SWIG_AsVal_int(obj3, &val4);
44589 if (!SWIG_IsOK(ecode4)) {
44590 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44591 }
44592 arg4 = static_cast< int >(val4);
44593 if (obj4) {
44594 arg5 = obj4;
44595 }
44596 {
44597 PyThreadState* __tstate = wxPyBeginAllowThreads();
44598 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44599 wxPyEndAllowThreads(__tstate);
44600 if (PyErr_Occurred()) SWIG_fail;
44601 }
44602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44603 return resultobj;
44604 fail:
44605 return NULL;
44606 }
44607
44608
44609 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44610 PyObject *resultobj = 0;
44611 int arg1 ;
44612 int arg2 ;
44613 int arg3 ;
44614 int arg4 ;
44615 int arg5 ;
44616 PyObject *arg6 = (PyObject *) NULL ;
44617 wxSizerItem *result = 0 ;
44618 int val1 ;
44619 int ecode1 = 0 ;
44620 int val2 ;
44621 int ecode2 = 0 ;
44622 int val3 ;
44623 int ecode3 = 0 ;
44624 int val4 ;
44625 int ecode4 = 0 ;
44626 int val5 ;
44627 int ecode5 = 0 ;
44628 PyObject * obj0 = 0 ;
44629 PyObject * obj1 = 0 ;
44630 PyObject * obj2 = 0 ;
44631 PyObject * obj3 = 0 ;
44632 PyObject * obj4 = 0 ;
44633 PyObject * obj5 = 0 ;
44634 char * kwnames[] = {
44635 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44636 };
44637
44638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44639 ecode1 = SWIG_AsVal_int(obj0, &val1);
44640 if (!SWIG_IsOK(ecode1)) {
44641 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44642 }
44643 arg1 = static_cast< int >(val1);
44644 ecode2 = SWIG_AsVal_int(obj1, &val2);
44645 if (!SWIG_IsOK(ecode2)) {
44646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44647 }
44648 arg2 = static_cast< int >(val2);
44649 ecode3 = SWIG_AsVal_int(obj2, &val3);
44650 if (!SWIG_IsOK(ecode3)) {
44651 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44652 }
44653 arg3 = static_cast< int >(val3);
44654 ecode4 = SWIG_AsVal_int(obj3, &val4);
44655 if (!SWIG_IsOK(ecode4)) {
44656 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44657 }
44658 arg4 = static_cast< int >(val4);
44659 ecode5 = SWIG_AsVal_int(obj4, &val5);
44660 if (!SWIG_IsOK(ecode5)) {
44661 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44662 }
44663 arg5 = static_cast< int >(val5);
44664 if (obj5) {
44665 arg6 = obj5;
44666 }
44667 {
44668 PyThreadState* __tstate = wxPyBeginAllowThreads();
44669 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44670 wxPyEndAllowThreads(__tstate);
44671 if (PyErr_Occurred()) SWIG_fail;
44672 }
44673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44674 return resultobj;
44675 fail:
44676 return NULL;
44677 }
44678
44679
44680 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44681 PyObject *resultobj = 0;
44682 wxSizer *arg1 = (wxSizer *) 0 ;
44683 int arg2 ;
44684 int arg3 ;
44685 int arg4 ;
44686 PyObject *arg5 = (PyObject *) NULL ;
44687 wxSizerItem *result = 0 ;
44688 int res1 = 0 ;
44689 int val2 ;
44690 int ecode2 = 0 ;
44691 int val3 ;
44692 int ecode3 = 0 ;
44693 int val4 ;
44694 int ecode4 = 0 ;
44695 PyObject * obj0 = 0 ;
44696 PyObject * obj1 = 0 ;
44697 PyObject * obj2 = 0 ;
44698 PyObject * obj3 = 0 ;
44699 PyObject * obj4 = 0 ;
44700 char * kwnames[] = {
44701 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44702 };
44703
44704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44705 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44706 if (!SWIG_IsOK(res1)) {
44707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44708 }
44709 ecode2 = SWIG_AsVal_int(obj1, &val2);
44710 if (!SWIG_IsOK(ecode2)) {
44711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44712 }
44713 arg2 = static_cast< int >(val2);
44714 ecode3 = SWIG_AsVal_int(obj2, &val3);
44715 if (!SWIG_IsOK(ecode3)) {
44716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44717 }
44718 arg3 = static_cast< int >(val3);
44719 ecode4 = SWIG_AsVal_int(obj3, &val4);
44720 if (!SWIG_IsOK(ecode4)) {
44721 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44722 }
44723 arg4 = static_cast< int >(val4);
44724 if (obj4) {
44725 arg5 = obj4;
44726 }
44727 {
44728 PyThreadState* __tstate = wxPyBeginAllowThreads();
44729 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44730 wxPyEndAllowThreads(__tstate);
44731 if (PyErr_Occurred()) SWIG_fail;
44732 }
44733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44734 return resultobj;
44735 fail:
44736 return NULL;
44737 }
44738
44739
44740 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44741 PyObject *resultobj = 0;
44742 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44743 void *argp1 = 0 ;
44744 int res1 = 0 ;
44745 PyObject *swig_obj[1] ;
44746
44747 if (!args) SWIG_fail;
44748 swig_obj[0] = args;
44749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44750 if (!SWIG_IsOK(res1)) {
44751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44752 }
44753 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44754 {
44755 PyThreadState* __tstate = wxPyBeginAllowThreads();
44756 (arg1)->DeleteWindows();
44757 wxPyEndAllowThreads(__tstate);
44758 if (PyErr_Occurred()) SWIG_fail;
44759 }
44760 resultobj = SWIG_Py_Void();
44761 return resultobj;
44762 fail:
44763 return NULL;
44764 }
44765
44766
44767 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44768 PyObject *resultobj = 0;
44769 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44770 void *argp1 = 0 ;
44771 int res1 = 0 ;
44772 PyObject *swig_obj[1] ;
44773
44774 if (!args) SWIG_fail;
44775 swig_obj[0] = args;
44776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44777 if (!SWIG_IsOK(res1)) {
44778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44779 }
44780 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44781 {
44782 PyThreadState* __tstate = wxPyBeginAllowThreads();
44783 (arg1)->DetachSizer();
44784 wxPyEndAllowThreads(__tstate);
44785 if (PyErr_Occurred()) SWIG_fail;
44786 }
44787 resultobj = SWIG_Py_Void();
44788 return resultobj;
44789 fail:
44790 return NULL;
44791 }
44792
44793
44794 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44795 PyObject *resultobj = 0;
44796 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44797 wxSize result;
44798 void *argp1 = 0 ;
44799 int res1 = 0 ;
44800 PyObject *swig_obj[1] ;
44801
44802 if (!args) SWIG_fail;
44803 swig_obj[0] = args;
44804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44805 if (!SWIG_IsOK(res1)) {
44806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44807 }
44808 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44809 {
44810 PyThreadState* __tstate = wxPyBeginAllowThreads();
44811 result = (arg1)->GetSize();
44812 wxPyEndAllowThreads(__tstate);
44813 if (PyErr_Occurred()) SWIG_fail;
44814 }
44815 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44816 return resultobj;
44817 fail:
44818 return NULL;
44819 }
44820
44821
44822 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44823 PyObject *resultobj = 0;
44824 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44825 wxSize result;
44826 void *argp1 = 0 ;
44827 int res1 = 0 ;
44828 PyObject *swig_obj[1] ;
44829
44830 if (!args) SWIG_fail;
44831 swig_obj[0] = args;
44832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44833 if (!SWIG_IsOK(res1)) {
44834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44835 }
44836 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44837 {
44838 PyThreadState* __tstate = wxPyBeginAllowThreads();
44839 result = (arg1)->CalcMin();
44840 wxPyEndAllowThreads(__tstate);
44841 if (PyErr_Occurred()) SWIG_fail;
44842 }
44843 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44844 return resultobj;
44845 fail:
44846 return NULL;
44847 }
44848
44849
44850 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44851 PyObject *resultobj = 0;
44852 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44853 wxPoint *arg2 = 0 ;
44854 wxSize *arg3 = 0 ;
44855 void *argp1 = 0 ;
44856 int res1 = 0 ;
44857 wxPoint temp2 ;
44858 wxSize temp3 ;
44859 PyObject * obj0 = 0 ;
44860 PyObject * obj1 = 0 ;
44861 PyObject * obj2 = 0 ;
44862 char * kwnames[] = {
44863 (char *) "self",(char *) "pos",(char *) "size", NULL
44864 };
44865
44866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44868 if (!SWIG_IsOK(res1)) {
44869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44870 }
44871 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44872 {
44873 arg2 = &temp2;
44874 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44875 }
44876 {
44877 arg3 = &temp3;
44878 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
44879 }
44880 {
44881 PyThreadState* __tstate = wxPyBeginAllowThreads();
44882 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
44883 wxPyEndAllowThreads(__tstate);
44884 if (PyErr_Occurred()) SWIG_fail;
44885 }
44886 resultobj = SWIG_Py_Void();
44887 return resultobj;
44888 fail:
44889 return NULL;
44890 }
44891
44892
44893 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44894 PyObject *resultobj = 0;
44895 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44896 wxSize result;
44897 void *argp1 = 0 ;
44898 int res1 = 0 ;
44899 PyObject *swig_obj[1] ;
44900
44901 if (!args) SWIG_fail;
44902 swig_obj[0] = args;
44903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44904 if (!SWIG_IsOK(res1)) {
44905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44906 }
44907 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44908 {
44909 PyThreadState* __tstate = wxPyBeginAllowThreads();
44910 result = (arg1)->GetMinSize();
44911 wxPyEndAllowThreads(__tstate);
44912 if (PyErr_Occurred()) SWIG_fail;
44913 }
44914 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44915 return resultobj;
44916 fail:
44917 return NULL;
44918 }
44919
44920
44921 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44922 PyObject *resultobj = 0;
44923 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44924 wxSize result;
44925 void *argp1 = 0 ;
44926 int res1 = 0 ;
44927 PyObject *swig_obj[1] ;
44928
44929 if (!args) SWIG_fail;
44930 swig_obj[0] = args;
44931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44932 if (!SWIG_IsOK(res1)) {
44933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
44934 }
44935 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44936 {
44937 PyThreadState* __tstate = wxPyBeginAllowThreads();
44938 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
44939 wxPyEndAllowThreads(__tstate);
44940 if (PyErr_Occurred()) SWIG_fail;
44941 }
44942 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44943 return resultobj;
44944 fail:
44945 return NULL;
44946 }
44947
44948
44949 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44950 PyObject *resultobj = 0;
44951 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44952 int arg2 ;
44953 int arg3 ;
44954 void *argp1 = 0 ;
44955 int res1 = 0 ;
44956 int val2 ;
44957 int ecode2 = 0 ;
44958 int val3 ;
44959 int ecode3 = 0 ;
44960 PyObject * obj0 = 0 ;
44961 PyObject * obj1 = 0 ;
44962 PyObject * obj2 = 0 ;
44963 char * kwnames[] = {
44964 (char *) "self",(char *) "x",(char *) "y", NULL
44965 };
44966
44967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44969 if (!SWIG_IsOK(res1)) {
44970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44971 }
44972 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44973 ecode2 = SWIG_AsVal_int(obj1, &val2);
44974 if (!SWIG_IsOK(ecode2)) {
44975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
44976 }
44977 arg2 = static_cast< int >(val2);
44978 ecode3 = SWIG_AsVal_int(obj2, &val3);
44979 if (!SWIG_IsOK(ecode3)) {
44980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
44981 }
44982 arg3 = static_cast< int >(val3);
44983 {
44984 PyThreadState* __tstate = wxPyBeginAllowThreads();
44985 (arg1)->SetInitSize(arg2,arg3);
44986 wxPyEndAllowThreads(__tstate);
44987 if (PyErr_Occurred()) SWIG_fail;
44988 }
44989 resultobj = SWIG_Py_Void();
44990 return resultobj;
44991 fail:
44992 return NULL;
44993 }
44994
44995
44996 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44997 PyObject *resultobj = 0;
44998 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44999 int arg2 ;
45000 int arg3 ;
45001 void *argp1 = 0 ;
45002 int res1 = 0 ;
45003 int val2 ;
45004 int ecode2 = 0 ;
45005 int val3 ;
45006 int ecode3 = 0 ;
45007 PyObject * obj0 = 0 ;
45008 PyObject * obj1 = 0 ;
45009 PyObject * obj2 = 0 ;
45010 char * kwnames[] = {
45011 (char *) "self",(char *) "width",(char *) "height", NULL
45012 };
45013
45014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45016 if (!SWIG_IsOK(res1)) {
45017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45018 }
45019 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45020 ecode2 = SWIG_AsVal_int(obj1, &val2);
45021 if (!SWIG_IsOK(ecode2)) {
45022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45023 }
45024 arg2 = static_cast< int >(val2);
45025 ecode3 = SWIG_AsVal_int(obj2, &val3);
45026 if (!SWIG_IsOK(ecode3)) {
45027 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45028 }
45029 arg3 = static_cast< int >(val3);
45030 {
45031 PyThreadState* __tstate = wxPyBeginAllowThreads();
45032 (arg1)->SetRatio(arg2,arg3);
45033 wxPyEndAllowThreads(__tstate);
45034 if (PyErr_Occurred()) SWIG_fail;
45035 }
45036 resultobj = SWIG_Py_Void();
45037 return resultobj;
45038 fail:
45039 return NULL;
45040 }
45041
45042
45043 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45044 PyObject *resultobj = 0;
45045 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45046 wxSize *arg2 = 0 ;
45047 void *argp1 = 0 ;
45048 int res1 = 0 ;
45049 wxSize temp2 ;
45050 PyObject * obj0 = 0 ;
45051 PyObject * obj1 = 0 ;
45052 char * kwnames[] = {
45053 (char *) "self",(char *) "size", NULL
45054 };
45055
45056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45058 if (!SWIG_IsOK(res1)) {
45059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45060 }
45061 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45062 {
45063 arg2 = &temp2;
45064 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45065 }
45066 {
45067 PyThreadState* __tstate = wxPyBeginAllowThreads();
45068 (arg1)->SetRatio((wxSize const &)*arg2);
45069 wxPyEndAllowThreads(__tstate);
45070 if (PyErr_Occurred()) SWIG_fail;
45071 }
45072 resultobj = SWIG_Py_Void();
45073 return resultobj;
45074 fail:
45075 return NULL;
45076 }
45077
45078
45079 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45080 PyObject *resultobj = 0;
45081 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45082 float arg2 ;
45083 void *argp1 = 0 ;
45084 int res1 = 0 ;
45085 float val2 ;
45086 int ecode2 = 0 ;
45087 PyObject * obj0 = 0 ;
45088 PyObject * obj1 = 0 ;
45089 char * kwnames[] = {
45090 (char *) "self",(char *) "ratio", NULL
45091 };
45092
45093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45095 if (!SWIG_IsOK(res1)) {
45096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45097 }
45098 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45099 ecode2 = SWIG_AsVal_float(obj1, &val2);
45100 if (!SWIG_IsOK(ecode2)) {
45101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45102 }
45103 arg2 = static_cast< float >(val2);
45104 {
45105 PyThreadState* __tstate = wxPyBeginAllowThreads();
45106 (arg1)->SetRatio(arg2);
45107 wxPyEndAllowThreads(__tstate);
45108 if (PyErr_Occurred()) SWIG_fail;
45109 }
45110 resultobj = SWIG_Py_Void();
45111 return resultobj;
45112 fail:
45113 return NULL;
45114 }
45115
45116
45117 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45118 PyObject *resultobj = 0;
45119 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45120 float result;
45121 void *argp1 = 0 ;
45122 int res1 = 0 ;
45123 PyObject *swig_obj[1] ;
45124
45125 if (!args) SWIG_fail;
45126 swig_obj[0] = args;
45127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45128 if (!SWIG_IsOK(res1)) {
45129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45130 }
45131 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45132 {
45133 PyThreadState* __tstate = wxPyBeginAllowThreads();
45134 result = (float)(arg1)->GetRatio();
45135 wxPyEndAllowThreads(__tstate);
45136 if (PyErr_Occurred()) SWIG_fail;
45137 }
45138 resultobj = SWIG_From_float(static_cast< float >(result));
45139 return resultobj;
45140 fail:
45141 return NULL;
45142 }
45143
45144
45145 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45146 PyObject *resultobj = 0;
45147 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45148 wxRect result;
45149 void *argp1 = 0 ;
45150 int res1 = 0 ;
45151 PyObject *swig_obj[1] ;
45152
45153 if (!args) SWIG_fail;
45154 swig_obj[0] = args;
45155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45156 if (!SWIG_IsOK(res1)) {
45157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45158 }
45159 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45160 {
45161 PyThreadState* __tstate = wxPyBeginAllowThreads();
45162 result = (arg1)->GetRect();
45163 wxPyEndAllowThreads(__tstate);
45164 if (PyErr_Occurred()) SWIG_fail;
45165 }
45166 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45167 return resultobj;
45168 fail:
45169 return NULL;
45170 }
45171
45172
45173 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45174 PyObject *resultobj = 0;
45175 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45176 bool result;
45177 void *argp1 = 0 ;
45178 int res1 = 0 ;
45179 PyObject *swig_obj[1] ;
45180
45181 if (!args) SWIG_fail;
45182 swig_obj[0] = args;
45183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45184 if (!SWIG_IsOK(res1)) {
45185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45186 }
45187 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45188 {
45189 PyThreadState* __tstate = wxPyBeginAllowThreads();
45190 result = (bool)(arg1)->IsWindow();
45191 wxPyEndAllowThreads(__tstate);
45192 if (PyErr_Occurred()) SWIG_fail;
45193 }
45194 {
45195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45196 }
45197 return resultobj;
45198 fail:
45199 return NULL;
45200 }
45201
45202
45203 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45204 PyObject *resultobj = 0;
45205 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45206 bool result;
45207 void *argp1 = 0 ;
45208 int res1 = 0 ;
45209 PyObject *swig_obj[1] ;
45210
45211 if (!args) SWIG_fail;
45212 swig_obj[0] = args;
45213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45214 if (!SWIG_IsOK(res1)) {
45215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45216 }
45217 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45218 {
45219 PyThreadState* __tstate = wxPyBeginAllowThreads();
45220 result = (bool)(arg1)->IsSizer();
45221 wxPyEndAllowThreads(__tstate);
45222 if (PyErr_Occurred()) SWIG_fail;
45223 }
45224 {
45225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45226 }
45227 return resultobj;
45228 fail:
45229 return NULL;
45230 }
45231
45232
45233 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45234 PyObject *resultobj = 0;
45235 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45236 bool result;
45237 void *argp1 = 0 ;
45238 int res1 = 0 ;
45239 PyObject *swig_obj[1] ;
45240
45241 if (!args) SWIG_fail;
45242 swig_obj[0] = args;
45243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45244 if (!SWIG_IsOK(res1)) {
45245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45246 }
45247 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45248 {
45249 PyThreadState* __tstate = wxPyBeginAllowThreads();
45250 result = (bool)(arg1)->IsSpacer();
45251 wxPyEndAllowThreads(__tstate);
45252 if (PyErr_Occurred()) SWIG_fail;
45253 }
45254 {
45255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45256 }
45257 return resultobj;
45258 fail:
45259 return NULL;
45260 }
45261
45262
45263 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45264 PyObject *resultobj = 0;
45265 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45266 int arg2 ;
45267 void *argp1 = 0 ;
45268 int res1 = 0 ;
45269 int val2 ;
45270 int ecode2 = 0 ;
45271 PyObject * obj0 = 0 ;
45272 PyObject * obj1 = 0 ;
45273 char * kwnames[] = {
45274 (char *) "self",(char *) "proportion", NULL
45275 };
45276
45277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45279 if (!SWIG_IsOK(res1)) {
45280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45281 }
45282 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45283 ecode2 = SWIG_AsVal_int(obj1, &val2);
45284 if (!SWIG_IsOK(ecode2)) {
45285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45286 }
45287 arg2 = static_cast< int >(val2);
45288 {
45289 PyThreadState* __tstate = wxPyBeginAllowThreads();
45290 (arg1)->SetProportion(arg2);
45291 wxPyEndAllowThreads(__tstate);
45292 if (PyErr_Occurred()) SWIG_fail;
45293 }
45294 resultobj = SWIG_Py_Void();
45295 return resultobj;
45296 fail:
45297 return NULL;
45298 }
45299
45300
45301 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45302 PyObject *resultobj = 0;
45303 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45304 int result;
45305 void *argp1 = 0 ;
45306 int res1 = 0 ;
45307 PyObject *swig_obj[1] ;
45308
45309 if (!args) SWIG_fail;
45310 swig_obj[0] = args;
45311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45312 if (!SWIG_IsOK(res1)) {
45313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45314 }
45315 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45316 {
45317 PyThreadState* __tstate = wxPyBeginAllowThreads();
45318 result = (int)(arg1)->GetProportion();
45319 wxPyEndAllowThreads(__tstate);
45320 if (PyErr_Occurred()) SWIG_fail;
45321 }
45322 resultobj = SWIG_From_int(static_cast< int >(result));
45323 return resultobj;
45324 fail:
45325 return NULL;
45326 }
45327
45328
45329 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45330 PyObject *resultobj = 0;
45331 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45332 int arg2 ;
45333 void *argp1 = 0 ;
45334 int res1 = 0 ;
45335 int val2 ;
45336 int ecode2 = 0 ;
45337 PyObject * obj0 = 0 ;
45338 PyObject * obj1 = 0 ;
45339 char * kwnames[] = {
45340 (char *) "self",(char *) "flag", NULL
45341 };
45342
45343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45345 if (!SWIG_IsOK(res1)) {
45346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45347 }
45348 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45349 ecode2 = SWIG_AsVal_int(obj1, &val2);
45350 if (!SWIG_IsOK(ecode2)) {
45351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45352 }
45353 arg2 = static_cast< int >(val2);
45354 {
45355 PyThreadState* __tstate = wxPyBeginAllowThreads();
45356 (arg1)->SetFlag(arg2);
45357 wxPyEndAllowThreads(__tstate);
45358 if (PyErr_Occurred()) SWIG_fail;
45359 }
45360 resultobj = SWIG_Py_Void();
45361 return resultobj;
45362 fail:
45363 return NULL;
45364 }
45365
45366
45367 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45368 PyObject *resultobj = 0;
45369 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45370 int result;
45371 void *argp1 = 0 ;
45372 int res1 = 0 ;
45373 PyObject *swig_obj[1] ;
45374
45375 if (!args) SWIG_fail;
45376 swig_obj[0] = args;
45377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45378 if (!SWIG_IsOK(res1)) {
45379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45380 }
45381 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45382 {
45383 PyThreadState* __tstate = wxPyBeginAllowThreads();
45384 result = (int)(arg1)->GetFlag();
45385 wxPyEndAllowThreads(__tstate);
45386 if (PyErr_Occurred()) SWIG_fail;
45387 }
45388 resultobj = SWIG_From_int(static_cast< int >(result));
45389 return resultobj;
45390 fail:
45391 return NULL;
45392 }
45393
45394
45395 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45396 PyObject *resultobj = 0;
45397 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45398 int arg2 ;
45399 void *argp1 = 0 ;
45400 int res1 = 0 ;
45401 int val2 ;
45402 int ecode2 = 0 ;
45403 PyObject * obj0 = 0 ;
45404 PyObject * obj1 = 0 ;
45405 char * kwnames[] = {
45406 (char *) "self",(char *) "border", NULL
45407 };
45408
45409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45411 if (!SWIG_IsOK(res1)) {
45412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45413 }
45414 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45415 ecode2 = SWIG_AsVal_int(obj1, &val2);
45416 if (!SWIG_IsOK(ecode2)) {
45417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45418 }
45419 arg2 = static_cast< int >(val2);
45420 {
45421 PyThreadState* __tstate = wxPyBeginAllowThreads();
45422 (arg1)->SetBorder(arg2);
45423 wxPyEndAllowThreads(__tstate);
45424 if (PyErr_Occurred()) SWIG_fail;
45425 }
45426 resultobj = SWIG_Py_Void();
45427 return resultobj;
45428 fail:
45429 return NULL;
45430 }
45431
45432
45433 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45434 PyObject *resultobj = 0;
45435 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45436 int result;
45437 void *argp1 = 0 ;
45438 int res1 = 0 ;
45439 PyObject *swig_obj[1] ;
45440
45441 if (!args) SWIG_fail;
45442 swig_obj[0] = args;
45443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45444 if (!SWIG_IsOK(res1)) {
45445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45446 }
45447 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45448 {
45449 PyThreadState* __tstate = wxPyBeginAllowThreads();
45450 result = (int)(arg1)->GetBorder();
45451 wxPyEndAllowThreads(__tstate);
45452 if (PyErr_Occurred()) SWIG_fail;
45453 }
45454 resultobj = SWIG_From_int(static_cast< int >(result));
45455 return resultobj;
45456 fail:
45457 return NULL;
45458 }
45459
45460
45461 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45462 PyObject *resultobj = 0;
45463 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45464 wxWindow *result = 0 ;
45465 void *argp1 = 0 ;
45466 int res1 = 0 ;
45467 PyObject *swig_obj[1] ;
45468
45469 if (!args) SWIG_fail;
45470 swig_obj[0] = args;
45471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45472 if (!SWIG_IsOK(res1)) {
45473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45474 }
45475 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45476 {
45477 PyThreadState* __tstate = wxPyBeginAllowThreads();
45478 result = (wxWindow *)(arg1)->GetWindow();
45479 wxPyEndAllowThreads(__tstate);
45480 if (PyErr_Occurred()) SWIG_fail;
45481 }
45482 {
45483 resultobj = wxPyMake_wxObject(result, 0);
45484 }
45485 return resultobj;
45486 fail:
45487 return NULL;
45488 }
45489
45490
45491 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45492 PyObject *resultobj = 0;
45493 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45494 wxWindow *arg2 = (wxWindow *) 0 ;
45495 void *argp1 = 0 ;
45496 int res1 = 0 ;
45497 void *argp2 = 0 ;
45498 int res2 = 0 ;
45499 PyObject * obj0 = 0 ;
45500 PyObject * obj1 = 0 ;
45501 char * kwnames[] = {
45502 (char *) "self",(char *) "window", NULL
45503 };
45504
45505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45507 if (!SWIG_IsOK(res1)) {
45508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45509 }
45510 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45511 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45512 if (!SWIG_IsOK(res2)) {
45513 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45514 }
45515 arg2 = reinterpret_cast< wxWindow * >(argp2);
45516 {
45517 PyThreadState* __tstate = wxPyBeginAllowThreads();
45518 (arg1)->SetWindow(arg2);
45519 wxPyEndAllowThreads(__tstate);
45520 if (PyErr_Occurred()) SWIG_fail;
45521 }
45522 resultobj = SWIG_Py_Void();
45523 return resultobj;
45524 fail:
45525 return NULL;
45526 }
45527
45528
45529 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45530 PyObject *resultobj = 0;
45531 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45532 wxSizer *result = 0 ;
45533 void *argp1 = 0 ;
45534 int res1 = 0 ;
45535 PyObject *swig_obj[1] ;
45536
45537 if (!args) SWIG_fail;
45538 swig_obj[0] = args;
45539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45540 if (!SWIG_IsOK(res1)) {
45541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45542 }
45543 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45544 {
45545 PyThreadState* __tstate = wxPyBeginAllowThreads();
45546 result = (wxSizer *)(arg1)->GetSizer();
45547 wxPyEndAllowThreads(__tstate);
45548 if (PyErr_Occurred()) SWIG_fail;
45549 }
45550 {
45551 resultobj = wxPyMake_wxObject(result, (bool)0);
45552 }
45553 return resultobj;
45554 fail:
45555 return NULL;
45556 }
45557
45558
45559 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45560 PyObject *resultobj = 0;
45561 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45562 wxSizer *arg2 = (wxSizer *) 0 ;
45563 void *argp1 = 0 ;
45564 int res1 = 0 ;
45565 int res2 = 0 ;
45566 PyObject * obj0 = 0 ;
45567 PyObject * obj1 = 0 ;
45568 char * kwnames[] = {
45569 (char *) "self",(char *) "sizer", NULL
45570 };
45571
45572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45574 if (!SWIG_IsOK(res1)) {
45575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45576 }
45577 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45578 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45579 if (!SWIG_IsOK(res2)) {
45580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45581 }
45582 {
45583 PyThreadState* __tstate = wxPyBeginAllowThreads();
45584 (arg1)->SetSizer(arg2);
45585 wxPyEndAllowThreads(__tstate);
45586 if (PyErr_Occurred()) SWIG_fail;
45587 }
45588 resultobj = SWIG_Py_Void();
45589 return resultobj;
45590 fail:
45591 return NULL;
45592 }
45593
45594
45595 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45596 PyObject *resultobj = 0;
45597 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45598 wxSize *result = 0 ;
45599 void *argp1 = 0 ;
45600 int res1 = 0 ;
45601 PyObject *swig_obj[1] ;
45602
45603 if (!args) SWIG_fail;
45604 swig_obj[0] = args;
45605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45606 if (!SWIG_IsOK(res1)) {
45607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45608 }
45609 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45610 {
45611 PyThreadState* __tstate = wxPyBeginAllowThreads();
45612 {
45613 wxSize const &_result_ref = (arg1)->GetSpacer();
45614 result = (wxSize *) &_result_ref;
45615 }
45616 wxPyEndAllowThreads(__tstate);
45617 if (PyErr_Occurred()) SWIG_fail;
45618 }
45619 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45620 return resultobj;
45621 fail:
45622 return NULL;
45623 }
45624
45625
45626 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45627 PyObject *resultobj = 0;
45628 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45629 wxSize *arg2 = 0 ;
45630 void *argp1 = 0 ;
45631 int res1 = 0 ;
45632 wxSize temp2 ;
45633 PyObject * obj0 = 0 ;
45634 PyObject * obj1 = 0 ;
45635 char * kwnames[] = {
45636 (char *) "self",(char *) "size", NULL
45637 };
45638
45639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45641 if (!SWIG_IsOK(res1)) {
45642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45643 }
45644 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45645 {
45646 arg2 = &temp2;
45647 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45648 }
45649 {
45650 PyThreadState* __tstate = wxPyBeginAllowThreads();
45651 (arg1)->SetSpacer((wxSize const &)*arg2);
45652 wxPyEndAllowThreads(__tstate);
45653 if (PyErr_Occurred()) SWIG_fail;
45654 }
45655 resultobj = SWIG_Py_Void();
45656 return resultobj;
45657 fail:
45658 return NULL;
45659 }
45660
45661
45662 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45663 PyObject *resultobj = 0;
45664 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45665 bool arg2 ;
45666 void *argp1 = 0 ;
45667 int res1 = 0 ;
45668 bool val2 ;
45669 int ecode2 = 0 ;
45670 PyObject * obj0 = 0 ;
45671 PyObject * obj1 = 0 ;
45672 char * kwnames[] = {
45673 (char *) "self",(char *) "show", NULL
45674 };
45675
45676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45678 if (!SWIG_IsOK(res1)) {
45679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45680 }
45681 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45682 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45683 if (!SWIG_IsOK(ecode2)) {
45684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45685 }
45686 arg2 = static_cast< bool >(val2);
45687 {
45688 PyThreadState* __tstate = wxPyBeginAllowThreads();
45689 (arg1)->Show(arg2);
45690 wxPyEndAllowThreads(__tstate);
45691 if (PyErr_Occurred()) SWIG_fail;
45692 }
45693 resultobj = SWIG_Py_Void();
45694 return resultobj;
45695 fail:
45696 return NULL;
45697 }
45698
45699
45700 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45701 PyObject *resultobj = 0;
45702 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45703 bool result;
45704 void *argp1 = 0 ;
45705 int res1 = 0 ;
45706 PyObject *swig_obj[1] ;
45707
45708 if (!args) SWIG_fail;
45709 swig_obj[0] = args;
45710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45711 if (!SWIG_IsOK(res1)) {
45712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45713 }
45714 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45715 {
45716 PyThreadState* __tstate = wxPyBeginAllowThreads();
45717 result = (bool)(arg1)->IsShown();
45718 wxPyEndAllowThreads(__tstate);
45719 if (PyErr_Occurred()) SWIG_fail;
45720 }
45721 {
45722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45723 }
45724 return resultobj;
45725 fail:
45726 return NULL;
45727 }
45728
45729
45730 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45731 PyObject *resultobj = 0;
45732 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45733 wxPoint 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_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45743 }
45744 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45745 {
45746 PyThreadState* __tstate = wxPyBeginAllowThreads();
45747 result = (arg1)->GetPosition();
45748 wxPyEndAllowThreads(__tstate);
45749 if (PyErr_Occurred()) SWIG_fail;
45750 }
45751 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
45752 return resultobj;
45753 fail:
45754 return NULL;
45755 }
45756
45757
45758 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45759 PyObject *resultobj = 0;
45760 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45761 PyObject *result = 0 ;
45762 void *argp1 = 0 ;
45763 int res1 = 0 ;
45764 PyObject *swig_obj[1] ;
45765
45766 if (!args) SWIG_fail;
45767 swig_obj[0] = args;
45768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45769 if (!SWIG_IsOK(res1)) {
45770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45771 }
45772 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45773 {
45774 PyThreadState* __tstate = wxPyBeginAllowThreads();
45775 result = (PyObject *)wxSizerItem_GetUserData(arg1);
45776 wxPyEndAllowThreads(__tstate);
45777 if (PyErr_Occurred()) SWIG_fail;
45778 }
45779 resultobj = result;
45780 return resultobj;
45781 fail:
45782 return NULL;
45783 }
45784
45785
45786 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45787 PyObject *resultobj = 0;
45788 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45789 PyObject *arg2 = (PyObject *) 0 ;
45790 void *argp1 = 0 ;
45791 int res1 = 0 ;
45792 PyObject * obj0 = 0 ;
45793 PyObject * obj1 = 0 ;
45794 char * kwnames[] = {
45795 (char *) "self",(char *) "userData", NULL
45796 };
45797
45798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
45799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45800 if (!SWIG_IsOK(res1)) {
45801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45802 }
45803 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45804 arg2 = obj1;
45805 {
45806 PyThreadState* __tstate = wxPyBeginAllowThreads();
45807 wxSizerItem_SetUserData(arg1,arg2);
45808 wxPyEndAllowThreads(__tstate);
45809 if (PyErr_Occurred()) SWIG_fail;
45810 }
45811 resultobj = SWIG_Py_Void();
45812 return resultobj;
45813 fail:
45814 return NULL;
45815 }
45816
45817
45818 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45819 PyObject *obj;
45820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45821 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
45822 return SWIG_Py_Void();
45823 }
45824
45825 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45826 return SWIG_Python_InitShadowInstance(args);
45827 }
45828
45829 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45830 PyObject *resultobj = 0;
45831 wxSizer *arg1 = (wxSizer *) 0 ;
45832 void *argp1 = 0 ;
45833 int res1 = 0 ;
45834 PyObject *swig_obj[1] ;
45835
45836 if (!args) SWIG_fail;
45837 swig_obj[0] = args;
45838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45839 if (!SWIG_IsOK(res1)) {
45840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45841 }
45842 arg1 = reinterpret_cast< wxSizer * >(argp1);
45843 {
45844 PyThreadState* __tstate = wxPyBeginAllowThreads();
45845 delete arg1;
45846
45847 wxPyEndAllowThreads(__tstate);
45848 if (PyErr_Occurred()) SWIG_fail;
45849 }
45850 resultobj = SWIG_Py_Void();
45851 return resultobj;
45852 fail:
45853 return NULL;
45854 }
45855
45856
45857 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45858 PyObject *resultobj = 0;
45859 wxSizer *arg1 = (wxSizer *) 0 ;
45860 PyObject *arg2 = (PyObject *) 0 ;
45861 void *argp1 = 0 ;
45862 int res1 = 0 ;
45863 PyObject * obj0 = 0 ;
45864 PyObject * obj1 = 0 ;
45865 char * kwnames[] = {
45866 (char *) "self",(char *) "_self", NULL
45867 };
45868
45869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
45870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45871 if (!SWIG_IsOK(res1)) {
45872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
45873 }
45874 arg1 = reinterpret_cast< wxSizer * >(argp1);
45875 arg2 = obj1;
45876 {
45877 PyThreadState* __tstate = wxPyBeginAllowThreads();
45878 wxSizer__setOORInfo(arg1,arg2);
45879 wxPyEndAllowThreads(__tstate);
45880 if (PyErr_Occurred()) SWIG_fail;
45881 }
45882 resultobj = SWIG_Py_Void();
45883 return resultobj;
45884 fail:
45885 return NULL;
45886 }
45887
45888
45889 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45890 PyObject *resultobj = 0;
45891 wxSizer *arg1 = (wxSizer *) 0 ;
45892 PyObject *arg2 = (PyObject *) 0 ;
45893 int arg3 = (int) 0 ;
45894 int arg4 = (int) 0 ;
45895 int arg5 = (int) 0 ;
45896 PyObject *arg6 = (PyObject *) NULL ;
45897 wxSizerItem *result = 0 ;
45898 void *argp1 = 0 ;
45899 int res1 = 0 ;
45900 int val3 ;
45901 int ecode3 = 0 ;
45902 int val4 ;
45903 int ecode4 = 0 ;
45904 int val5 ;
45905 int ecode5 = 0 ;
45906 PyObject * obj0 = 0 ;
45907 PyObject * obj1 = 0 ;
45908 PyObject * obj2 = 0 ;
45909 PyObject * obj3 = 0 ;
45910 PyObject * obj4 = 0 ;
45911 PyObject * obj5 = 0 ;
45912 char * kwnames[] = {
45913 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45914 };
45915
45916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45918 if (!SWIG_IsOK(res1)) {
45919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
45920 }
45921 arg1 = reinterpret_cast< wxSizer * >(argp1);
45922 arg2 = obj1;
45923 if (obj2) {
45924 ecode3 = SWIG_AsVal_int(obj2, &val3);
45925 if (!SWIG_IsOK(ecode3)) {
45926 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
45927 }
45928 arg3 = static_cast< int >(val3);
45929 }
45930 if (obj3) {
45931 ecode4 = SWIG_AsVal_int(obj3, &val4);
45932 if (!SWIG_IsOK(ecode4)) {
45933 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
45934 }
45935 arg4 = static_cast< int >(val4);
45936 }
45937 if (obj4) {
45938 ecode5 = SWIG_AsVal_int(obj4, &val5);
45939 if (!SWIG_IsOK(ecode5)) {
45940 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
45941 }
45942 arg5 = static_cast< int >(val5);
45943 }
45944 if (obj5) {
45945 arg6 = obj5;
45946 }
45947 {
45948 PyThreadState* __tstate = wxPyBeginAllowThreads();
45949 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
45950 wxPyEndAllowThreads(__tstate);
45951 if (PyErr_Occurred()) SWIG_fail;
45952 }
45953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
45954 return resultobj;
45955 fail:
45956 return NULL;
45957 }
45958
45959
45960 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45961 PyObject *resultobj = 0;
45962 wxSizer *arg1 = (wxSizer *) 0 ;
45963 int arg2 ;
45964 PyObject *arg3 = (PyObject *) 0 ;
45965 int arg4 = (int) 0 ;
45966 int arg5 = (int) 0 ;
45967 int arg6 = (int) 0 ;
45968 PyObject *arg7 = (PyObject *) NULL ;
45969 wxSizerItem *result = 0 ;
45970 void *argp1 = 0 ;
45971 int res1 = 0 ;
45972 int val2 ;
45973 int ecode2 = 0 ;
45974 int val4 ;
45975 int ecode4 = 0 ;
45976 int val5 ;
45977 int ecode5 = 0 ;
45978 int val6 ;
45979 int ecode6 = 0 ;
45980 PyObject * obj0 = 0 ;
45981 PyObject * obj1 = 0 ;
45982 PyObject * obj2 = 0 ;
45983 PyObject * obj3 = 0 ;
45984 PyObject * obj4 = 0 ;
45985 PyObject * obj5 = 0 ;
45986 PyObject * obj6 = 0 ;
45987 char * kwnames[] = {
45988 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45989 };
45990
45991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
45992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45993 if (!SWIG_IsOK(res1)) {
45994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
45995 }
45996 arg1 = reinterpret_cast< wxSizer * >(argp1);
45997 ecode2 = SWIG_AsVal_int(obj1, &val2);
45998 if (!SWIG_IsOK(ecode2)) {
45999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46000 }
46001 arg2 = static_cast< int >(val2);
46002 arg3 = obj2;
46003 if (obj3) {
46004 ecode4 = SWIG_AsVal_int(obj3, &val4);
46005 if (!SWIG_IsOK(ecode4)) {
46006 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46007 }
46008 arg4 = static_cast< int >(val4);
46009 }
46010 if (obj4) {
46011 ecode5 = SWIG_AsVal_int(obj4, &val5);
46012 if (!SWIG_IsOK(ecode5)) {
46013 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46014 }
46015 arg5 = static_cast< int >(val5);
46016 }
46017 if (obj5) {
46018 ecode6 = SWIG_AsVal_int(obj5, &val6);
46019 if (!SWIG_IsOK(ecode6)) {
46020 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46021 }
46022 arg6 = static_cast< int >(val6);
46023 }
46024 if (obj6) {
46025 arg7 = obj6;
46026 }
46027 {
46028 PyThreadState* __tstate = wxPyBeginAllowThreads();
46029 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46030 wxPyEndAllowThreads(__tstate);
46031 if (PyErr_Occurred()) SWIG_fail;
46032 }
46033 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46034 return resultobj;
46035 fail:
46036 return NULL;
46037 }
46038
46039
46040 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46041 PyObject *resultobj = 0;
46042 wxSizer *arg1 = (wxSizer *) 0 ;
46043 PyObject *arg2 = (PyObject *) 0 ;
46044 int arg3 = (int) 0 ;
46045 int arg4 = (int) 0 ;
46046 int arg5 = (int) 0 ;
46047 PyObject *arg6 = (PyObject *) NULL ;
46048 wxSizerItem *result = 0 ;
46049 void *argp1 = 0 ;
46050 int res1 = 0 ;
46051 int val3 ;
46052 int ecode3 = 0 ;
46053 int val4 ;
46054 int ecode4 = 0 ;
46055 int val5 ;
46056 int ecode5 = 0 ;
46057 PyObject * obj0 = 0 ;
46058 PyObject * obj1 = 0 ;
46059 PyObject * obj2 = 0 ;
46060 PyObject * obj3 = 0 ;
46061 PyObject * obj4 = 0 ;
46062 PyObject * obj5 = 0 ;
46063 char * kwnames[] = {
46064 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46065 };
46066
46067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46069 if (!SWIG_IsOK(res1)) {
46070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46071 }
46072 arg1 = reinterpret_cast< wxSizer * >(argp1);
46073 arg2 = obj1;
46074 if (obj2) {
46075 ecode3 = SWIG_AsVal_int(obj2, &val3);
46076 if (!SWIG_IsOK(ecode3)) {
46077 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46078 }
46079 arg3 = static_cast< int >(val3);
46080 }
46081 if (obj3) {
46082 ecode4 = SWIG_AsVal_int(obj3, &val4);
46083 if (!SWIG_IsOK(ecode4)) {
46084 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46085 }
46086 arg4 = static_cast< int >(val4);
46087 }
46088 if (obj4) {
46089 ecode5 = SWIG_AsVal_int(obj4, &val5);
46090 if (!SWIG_IsOK(ecode5)) {
46091 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46092 }
46093 arg5 = static_cast< int >(val5);
46094 }
46095 if (obj5) {
46096 arg6 = obj5;
46097 }
46098 {
46099 PyThreadState* __tstate = wxPyBeginAllowThreads();
46100 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46101 wxPyEndAllowThreads(__tstate);
46102 if (PyErr_Occurred()) SWIG_fail;
46103 }
46104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46105 return resultobj;
46106 fail:
46107 return NULL;
46108 }
46109
46110
46111 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46112 PyObject *resultobj = 0;
46113 wxSizer *arg1 = (wxSizer *) 0 ;
46114 PyObject *arg2 = (PyObject *) 0 ;
46115 bool result;
46116 void *argp1 = 0 ;
46117 int res1 = 0 ;
46118 PyObject * obj0 = 0 ;
46119 PyObject * obj1 = 0 ;
46120 char * kwnames[] = {
46121 (char *) "self",(char *) "item", NULL
46122 };
46123
46124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46126 if (!SWIG_IsOK(res1)) {
46127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46128 }
46129 arg1 = reinterpret_cast< wxSizer * >(argp1);
46130 arg2 = obj1;
46131 {
46132 PyThreadState* __tstate = wxPyBeginAllowThreads();
46133 result = (bool)wxSizer_Remove(arg1,arg2);
46134 wxPyEndAllowThreads(__tstate);
46135 if (PyErr_Occurred()) SWIG_fail;
46136 }
46137 {
46138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46139 }
46140 return resultobj;
46141 fail:
46142 return NULL;
46143 }
46144
46145
46146 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46147 PyObject *resultobj = 0;
46148 wxSizer *arg1 = (wxSizer *) 0 ;
46149 PyObject *arg2 = (PyObject *) 0 ;
46150 bool result;
46151 void *argp1 = 0 ;
46152 int res1 = 0 ;
46153 PyObject * obj0 = 0 ;
46154 PyObject * obj1 = 0 ;
46155 char * kwnames[] = {
46156 (char *) "self",(char *) "item", NULL
46157 };
46158
46159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46161 if (!SWIG_IsOK(res1)) {
46162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46163 }
46164 arg1 = reinterpret_cast< wxSizer * >(argp1);
46165 arg2 = obj1;
46166 {
46167 PyThreadState* __tstate = wxPyBeginAllowThreads();
46168 result = (bool)wxSizer_Detach(arg1,arg2);
46169 wxPyEndAllowThreads(__tstate);
46170 if (PyErr_Occurred()) SWIG_fail;
46171 }
46172 {
46173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46174 }
46175 return resultobj;
46176 fail:
46177 return NULL;
46178 }
46179
46180
46181 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46182 PyObject *resultobj = 0;
46183 wxSizer *arg1 = (wxSizer *) 0 ;
46184 PyObject *arg2 = (PyObject *) 0 ;
46185 wxSizerItem *result = 0 ;
46186 void *argp1 = 0 ;
46187 int res1 = 0 ;
46188 PyObject * obj0 = 0 ;
46189 PyObject * obj1 = 0 ;
46190 char * kwnames[] = {
46191 (char *) "self",(char *) "item", NULL
46192 };
46193
46194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46196 if (!SWIG_IsOK(res1)) {
46197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46198 }
46199 arg1 = reinterpret_cast< wxSizer * >(argp1);
46200 arg2 = obj1;
46201 {
46202 PyThreadState* __tstate = wxPyBeginAllowThreads();
46203 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46204 wxPyEndAllowThreads(__tstate);
46205 if (PyErr_Occurred()) SWIG_fail;
46206 }
46207 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46208 return resultobj;
46209 fail:
46210 return NULL;
46211 }
46212
46213
46214 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46215 PyObject *resultobj = 0;
46216 wxSizer *arg1 = (wxSizer *) 0 ;
46217 PyObject *arg2 = (PyObject *) 0 ;
46218 wxSize *arg3 = 0 ;
46219 void *argp1 = 0 ;
46220 int res1 = 0 ;
46221 wxSize temp3 ;
46222 PyObject * obj0 = 0 ;
46223 PyObject * obj1 = 0 ;
46224 PyObject * obj2 = 0 ;
46225 char * kwnames[] = {
46226 (char *) "self",(char *) "item",(char *) "size", NULL
46227 };
46228
46229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46231 if (!SWIG_IsOK(res1)) {
46232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46233 }
46234 arg1 = reinterpret_cast< wxSizer * >(argp1);
46235 arg2 = obj1;
46236 {
46237 arg3 = &temp3;
46238 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46239 }
46240 {
46241 PyThreadState* __tstate = wxPyBeginAllowThreads();
46242 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46243 wxPyEndAllowThreads(__tstate);
46244 if (PyErr_Occurred()) SWIG_fail;
46245 }
46246 resultobj = SWIG_Py_Void();
46247 return resultobj;
46248 fail:
46249 return NULL;
46250 }
46251
46252
46253 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46254 PyObject *resultobj = 0;
46255 wxSizer *arg1 = (wxSizer *) 0 ;
46256 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46257 wxSizerItem *result = 0 ;
46258 void *argp1 = 0 ;
46259 int res1 = 0 ;
46260 int res2 = 0 ;
46261 PyObject * obj0 = 0 ;
46262 PyObject * obj1 = 0 ;
46263 char * kwnames[] = {
46264 (char *) "self",(char *) "item", NULL
46265 };
46266
46267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46269 if (!SWIG_IsOK(res1)) {
46270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46271 }
46272 arg1 = reinterpret_cast< wxSizer * >(argp1);
46273 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46274 if (!SWIG_IsOK(res2)) {
46275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46276 }
46277 {
46278 PyThreadState* __tstate = wxPyBeginAllowThreads();
46279 result = (wxSizerItem *)(arg1)->Add(arg2);
46280 wxPyEndAllowThreads(__tstate);
46281 if (PyErr_Occurred()) SWIG_fail;
46282 }
46283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46284 return resultobj;
46285 fail:
46286 return NULL;
46287 }
46288
46289
46290 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46291 PyObject *resultobj = 0;
46292 wxSizer *arg1 = (wxSizer *) 0 ;
46293 size_t arg2 ;
46294 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46295 wxSizerItem *result = 0 ;
46296 void *argp1 = 0 ;
46297 int res1 = 0 ;
46298 size_t val2 ;
46299 int ecode2 = 0 ;
46300 int res3 = 0 ;
46301 PyObject * obj0 = 0 ;
46302 PyObject * obj1 = 0 ;
46303 PyObject * obj2 = 0 ;
46304 char * kwnames[] = {
46305 (char *) "self",(char *) "index",(char *) "item", NULL
46306 };
46307
46308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46310 if (!SWIG_IsOK(res1)) {
46311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46312 }
46313 arg1 = reinterpret_cast< wxSizer * >(argp1);
46314 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46315 if (!SWIG_IsOK(ecode2)) {
46316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46317 }
46318 arg2 = static_cast< size_t >(val2);
46319 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46320 if (!SWIG_IsOK(res3)) {
46321 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46322 }
46323 {
46324 PyThreadState* __tstate = wxPyBeginAllowThreads();
46325 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46326 wxPyEndAllowThreads(__tstate);
46327 if (PyErr_Occurred()) SWIG_fail;
46328 }
46329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46330 return resultobj;
46331 fail:
46332 return NULL;
46333 }
46334
46335
46336 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46337 PyObject *resultobj = 0;
46338 wxSizer *arg1 = (wxSizer *) 0 ;
46339 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46340 wxSizerItem *result = 0 ;
46341 void *argp1 = 0 ;
46342 int res1 = 0 ;
46343 int res2 = 0 ;
46344 PyObject * obj0 = 0 ;
46345 PyObject * obj1 = 0 ;
46346 char * kwnames[] = {
46347 (char *) "self",(char *) "item", NULL
46348 };
46349
46350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46352 if (!SWIG_IsOK(res1)) {
46353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46354 }
46355 arg1 = reinterpret_cast< wxSizer * >(argp1);
46356 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46357 if (!SWIG_IsOK(res2)) {
46358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46359 }
46360 {
46361 PyThreadState* __tstate = wxPyBeginAllowThreads();
46362 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46363 wxPyEndAllowThreads(__tstate);
46364 if (PyErr_Occurred()) SWIG_fail;
46365 }
46366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46367 return resultobj;
46368 fail:
46369 return NULL;
46370 }
46371
46372
46373 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46374 PyObject *resultobj = 0;
46375 wxSizer *arg1 = (wxSizer *) 0 ;
46376 int arg2 ;
46377 int arg3 ;
46378 int arg4 ;
46379 int arg5 ;
46380 void *argp1 = 0 ;
46381 int res1 = 0 ;
46382 int val2 ;
46383 int ecode2 = 0 ;
46384 int val3 ;
46385 int ecode3 = 0 ;
46386 int val4 ;
46387 int ecode4 = 0 ;
46388 int val5 ;
46389 int ecode5 = 0 ;
46390 PyObject * obj0 = 0 ;
46391 PyObject * obj1 = 0 ;
46392 PyObject * obj2 = 0 ;
46393 PyObject * obj3 = 0 ;
46394 PyObject * obj4 = 0 ;
46395 char * kwnames[] = {
46396 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46397 };
46398
46399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46401 if (!SWIG_IsOK(res1)) {
46402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46403 }
46404 arg1 = reinterpret_cast< wxSizer * >(argp1);
46405 ecode2 = SWIG_AsVal_int(obj1, &val2);
46406 if (!SWIG_IsOK(ecode2)) {
46407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46408 }
46409 arg2 = static_cast< int >(val2);
46410 ecode3 = SWIG_AsVal_int(obj2, &val3);
46411 if (!SWIG_IsOK(ecode3)) {
46412 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46413 }
46414 arg3 = static_cast< int >(val3);
46415 ecode4 = SWIG_AsVal_int(obj3, &val4);
46416 if (!SWIG_IsOK(ecode4)) {
46417 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46418 }
46419 arg4 = static_cast< int >(val4);
46420 ecode5 = SWIG_AsVal_int(obj4, &val5);
46421 if (!SWIG_IsOK(ecode5)) {
46422 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46423 }
46424 arg5 = static_cast< int >(val5);
46425 {
46426 PyThreadState* __tstate = wxPyBeginAllowThreads();
46427 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46428 wxPyEndAllowThreads(__tstate);
46429 if (PyErr_Occurred()) SWIG_fail;
46430 }
46431 resultobj = SWIG_Py_Void();
46432 return resultobj;
46433 fail:
46434 return NULL;
46435 }
46436
46437
46438 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46439 PyObject *resultobj = 0;
46440 wxSizer *arg1 = (wxSizer *) 0 ;
46441 wxSize *arg2 = 0 ;
46442 void *argp1 = 0 ;
46443 int res1 = 0 ;
46444 wxSize temp2 ;
46445 PyObject * obj0 = 0 ;
46446 PyObject * obj1 = 0 ;
46447 char * kwnames[] = {
46448 (char *) "self",(char *) "size", NULL
46449 };
46450
46451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46453 if (!SWIG_IsOK(res1)) {
46454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46455 }
46456 arg1 = reinterpret_cast< wxSizer * >(argp1);
46457 {
46458 arg2 = &temp2;
46459 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46460 }
46461 {
46462 PyThreadState* __tstate = wxPyBeginAllowThreads();
46463 (arg1)->SetMinSize((wxSize const &)*arg2);
46464 wxPyEndAllowThreads(__tstate);
46465 if (PyErr_Occurred()) SWIG_fail;
46466 }
46467 resultobj = SWIG_Py_Void();
46468 return resultobj;
46469 fail:
46470 return NULL;
46471 }
46472
46473
46474 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46475 PyObject *resultobj = 0;
46476 wxSizer *arg1 = (wxSizer *) 0 ;
46477 wxSize result;
46478 void *argp1 = 0 ;
46479 int res1 = 0 ;
46480 PyObject *swig_obj[1] ;
46481
46482 if (!args) SWIG_fail;
46483 swig_obj[0] = args;
46484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46485 if (!SWIG_IsOK(res1)) {
46486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46487 }
46488 arg1 = reinterpret_cast< wxSizer * >(argp1);
46489 {
46490 PyThreadState* __tstate = wxPyBeginAllowThreads();
46491 result = (arg1)->GetSize();
46492 wxPyEndAllowThreads(__tstate);
46493 if (PyErr_Occurred()) SWIG_fail;
46494 }
46495 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46496 return resultobj;
46497 fail:
46498 return NULL;
46499 }
46500
46501
46502 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46503 PyObject *resultobj = 0;
46504 wxSizer *arg1 = (wxSizer *) 0 ;
46505 wxPoint result;
46506 void *argp1 = 0 ;
46507 int res1 = 0 ;
46508 PyObject *swig_obj[1] ;
46509
46510 if (!args) SWIG_fail;
46511 swig_obj[0] = args;
46512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46513 if (!SWIG_IsOK(res1)) {
46514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46515 }
46516 arg1 = reinterpret_cast< wxSizer * >(argp1);
46517 {
46518 PyThreadState* __tstate = wxPyBeginAllowThreads();
46519 result = (arg1)->GetPosition();
46520 wxPyEndAllowThreads(__tstate);
46521 if (PyErr_Occurred()) SWIG_fail;
46522 }
46523 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46524 return resultobj;
46525 fail:
46526 return NULL;
46527 }
46528
46529
46530 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46531 PyObject *resultobj = 0;
46532 wxSizer *arg1 = (wxSizer *) 0 ;
46533 wxSize result;
46534 void *argp1 = 0 ;
46535 int res1 = 0 ;
46536 PyObject *swig_obj[1] ;
46537
46538 if (!args) SWIG_fail;
46539 swig_obj[0] = args;
46540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46541 if (!SWIG_IsOK(res1)) {
46542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46543 }
46544 arg1 = reinterpret_cast< wxSizer * >(argp1);
46545 {
46546 PyThreadState* __tstate = wxPyBeginAllowThreads();
46547 result = (arg1)->GetMinSize();
46548 wxPyEndAllowThreads(__tstate);
46549 if (PyErr_Occurred()) SWIG_fail;
46550 }
46551 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46552 return resultobj;
46553 fail:
46554 return NULL;
46555 }
46556
46557
46558 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46559 PyObject *resultobj = 0;
46560 wxSizer *arg1 = (wxSizer *) 0 ;
46561 void *argp1 = 0 ;
46562 int res1 = 0 ;
46563 PyObject *swig_obj[1] ;
46564
46565 if (!args) SWIG_fail;
46566 swig_obj[0] = args;
46567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46568 if (!SWIG_IsOK(res1)) {
46569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46570 }
46571 arg1 = reinterpret_cast< wxSizer * >(argp1);
46572 {
46573 PyThreadState* __tstate = wxPyBeginAllowThreads();
46574 (arg1)->RecalcSizes();
46575 wxPyEndAllowThreads(__tstate);
46576 if (PyErr_Occurred()) SWIG_fail;
46577 }
46578 resultobj = SWIG_Py_Void();
46579 return resultobj;
46580 fail:
46581 return NULL;
46582 }
46583
46584
46585 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46586 PyObject *resultobj = 0;
46587 wxSizer *arg1 = (wxSizer *) 0 ;
46588 wxSize result;
46589 void *argp1 = 0 ;
46590 int res1 = 0 ;
46591 PyObject *swig_obj[1] ;
46592
46593 if (!args) SWIG_fail;
46594 swig_obj[0] = args;
46595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46596 if (!SWIG_IsOK(res1)) {
46597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46598 }
46599 arg1 = reinterpret_cast< wxSizer * >(argp1);
46600 {
46601 PyThreadState* __tstate = wxPyBeginAllowThreads();
46602 result = (arg1)->CalcMin();
46603 wxPyEndAllowThreads(__tstate);
46604 if (PyErr_Occurred()) SWIG_fail;
46605 }
46606 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46607 return resultobj;
46608 fail:
46609 return NULL;
46610 }
46611
46612
46613 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46614 PyObject *resultobj = 0;
46615 wxSizer *arg1 = (wxSizer *) 0 ;
46616 void *argp1 = 0 ;
46617 int res1 = 0 ;
46618 PyObject *swig_obj[1] ;
46619
46620 if (!args) SWIG_fail;
46621 swig_obj[0] = args;
46622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46623 if (!SWIG_IsOK(res1)) {
46624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46625 }
46626 arg1 = reinterpret_cast< wxSizer * >(argp1);
46627 {
46628 PyThreadState* __tstate = wxPyBeginAllowThreads();
46629 (arg1)->Layout();
46630 wxPyEndAllowThreads(__tstate);
46631 if (PyErr_Occurred()) SWIG_fail;
46632 }
46633 resultobj = SWIG_Py_Void();
46634 return resultobj;
46635 fail:
46636 return NULL;
46637 }
46638
46639
46640 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46641 PyObject *resultobj = 0;
46642 wxSizer *arg1 = (wxSizer *) 0 ;
46643 wxWindow *arg2 = (wxWindow *) 0 ;
46644 wxSize result;
46645 void *argp1 = 0 ;
46646 int res1 = 0 ;
46647 void *argp2 = 0 ;
46648 int res2 = 0 ;
46649 PyObject * obj0 = 0 ;
46650 PyObject * obj1 = 0 ;
46651 char * kwnames[] = {
46652 (char *) "self",(char *) "window", NULL
46653 };
46654
46655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46657 if (!SWIG_IsOK(res1)) {
46658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46659 }
46660 arg1 = reinterpret_cast< wxSizer * >(argp1);
46661 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46662 if (!SWIG_IsOK(res2)) {
46663 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46664 }
46665 arg2 = reinterpret_cast< wxWindow * >(argp2);
46666 {
46667 PyThreadState* __tstate = wxPyBeginAllowThreads();
46668 result = (arg1)->Fit(arg2);
46669 wxPyEndAllowThreads(__tstate);
46670 if (PyErr_Occurred()) SWIG_fail;
46671 }
46672 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46673 return resultobj;
46674 fail:
46675 return NULL;
46676 }
46677
46678
46679 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46680 PyObject *resultobj = 0;
46681 wxSizer *arg1 = (wxSizer *) 0 ;
46682 wxWindow *arg2 = (wxWindow *) 0 ;
46683 void *argp1 = 0 ;
46684 int res1 = 0 ;
46685 void *argp2 = 0 ;
46686 int res2 = 0 ;
46687 PyObject * obj0 = 0 ;
46688 PyObject * obj1 = 0 ;
46689 char * kwnames[] = {
46690 (char *) "self",(char *) "window", NULL
46691 };
46692
46693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46695 if (!SWIG_IsOK(res1)) {
46696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46697 }
46698 arg1 = reinterpret_cast< wxSizer * >(argp1);
46699 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46700 if (!SWIG_IsOK(res2)) {
46701 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46702 }
46703 arg2 = reinterpret_cast< wxWindow * >(argp2);
46704 {
46705 PyThreadState* __tstate = wxPyBeginAllowThreads();
46706 (arg1)->FitInside(arg2);
46707 wxPyEndAllowThreads(__tstate);
46708 if (PyErr_Occurred()) SWIG_fail;
46709 }
46710 resultobj = SWIG_Py_Void();
46711 return resultobj;
46712 fail:
46713 return NULL;
46714 }
46715
46716
46717 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46718 PyObject *resultobj = 0;
46719 wxSizer *arg1 = (wxSizer *) 0 ;
46720 wxWindow *arg2 = (wxWindow *) 0 ;
46721 void *argp1 = 0 ;
46722 int res1 = 0 ;
46723 void *argp2 = 0 ;
46724 int res2 = 0 ;
46725 PyObject * obj0 = 0 ;
46726 PyObject * obj1 = 0 ;
46727 char * kwnames[] = {
46728 (char *) "self",(char *) "window", NULL
46729 };
46730
46731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46733 if (!SWIG_IsOK(res1)) {
46734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46735 }
46736 arg1 = reinterpret_cast< wxSizer * >(argp1);
46737 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46738 if (!SWIG_IsOK(res2)) {
46739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46740 }
46741 arg2 = reinterpret_cast< wxWindow * >(argp2);
46742 {
46743 PyThreadState* __tstate = wxPyBeginAllowThreads();
46744 (arg1)->SetSizeHints(arg2);
46745 wxPyEndAllowThreads(__tstate);
46746 if (PyErr_Occurred()) SWIG_fail;
46747 }
46748 resultobj = SWIG_Py_Void();
46749 return resultobj;
46750 fail:
46751 return NULL;
46752 }
46753
46754
46755 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46756 PyObject *resultobj = 0;
46757 wxSizer *arg1 = (wxSizer *) 0 ;
46758 wxWindow *arg2 = (wxWindow *) 0 ;
46759 void *argp1 = 0 ;
46760 int res1 = 0 ;
46761 void *argp2 = 0 ;
46762 int res2 = 0 ;
46763 PyObject * obj0 = 0 ;
46764 PyObject * obj1 = 0 ;
46765 char * kwnames[] = {
46766 (char *) "self",(char *) "window", NULL
46767 };
46768
46769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46771 if (!SWIG_IsOK(res1)) {
46772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46773 }
46774 arg1 = reinterpret_cast< wxSizer * >(argp1);
46775 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46776 if (!SWIG_IsOK(res2)) {
46777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46778 }
46779 arg2 = reinterpret_cast< wxWindow * >(argp2);
46780 {
46781 PyThreadState* __tstate = wxPyBeginAllowThreads();
46782 (arg1)->SetVirtualSizeHints(arg2);
46783 wxPyEndAllowThreads(__tstate);
46784 if (PyErr_Occurred()) SWIG_fail;
46785 }
46786 resultobj = SWIG_Py_Void();
46787 return resultobj;
46788 fail:
46789 return NULL;
46790 }
46791
46792
46793 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46794 PyObject *resultobj = 0;
46795 wxSizer *arg1 = (wxSizer *) 0 ;
46796 bool arg2 = (bool) false ;
46797 void *argp1 = 0 ;
46798 int res1 = 0 ;
46799 bool val2 ;
46800 int ecode2 = 0 ;
46801 PyObject * obj0 = 0 ;
46802 PyObject * obj1 = 0 ;
46803 char * kwnames[] = {
46804 (char *) "self",(char *) "deleteWindows", NULL
46805 };
46806
46807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
46808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46809 if (!SWIG_IsOK(res1)) {
46810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
46811 }
46812 arg1 = reinterpret_cast< wxSizer * >(argp1);
46813 if (obj1) {
46814 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46815 if (!SWIG_IsOK(ecode2)) {
46816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
46817 }
46818 arg2 = static_cast< bool >(val2);
46819 }
46820 {
46821 PyThreadState* __tstate = wxPyBeginAllowThreads();
46822 (arg1)->Clear(arg2);
46823 wxPyEndAllowThreads(__tstate);
46824 if (PyErr_Occurred()) SWIG_fail;
46825 }
46826 resultobj = SWIG_Py_Void();
46827 return resultobj;
46828 fail:
46829 return NULL;
46830 }
46831
46832
46833 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46834 PyObject *resultobj = 0;
46835 wxSizer *arg1 = (wxSizer *) 0 ;
46836 void *argp1 = 0 ;
46837 int res1 = 0 ;
46838 PyObject *swig_obj[1] ;
46839
46840 if (!args) SWIG_fail;
46841 swig_obj[0] = args;
46842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46843 if (!SWIG_IsOK(res1)) {
46844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
46845 }
46846 arg1 = reinterpret_cast< wxSizer * >(argp1);
46847 {
46848 PyThreadState* __tstate = wxPyBeginAllowThreads();
46849 (arg1)->DeleteWindows();
46850 wxPyEndAllowThreads(__tstate);
46851 if (PyErr_Occurred()) SWIG_fail;
46852 }
46853 resultobj = SWIG_Py_Void();
46854 return resultobj;
46855 fail:
46856 return NULL;
46857 }
46858
46859
46860 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46861 PyObject *resultobj = 0;
46862 wxSizer *arg1 = (wxSizer *) 0 ;
46863 PyObject *result = 0 ;
46864 void *argp1 = 0 ;
46865 int res1 = 0 ;
46866 PyObject *swig_obj[1] ;
46867
46868 if (!args) SWIG_fail;
46869 swig_obj[0] = args;
46870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46871 if (!SWIG_IsOK(res1)) {
46872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
46873 }
46874 arg1 = reinterpret_cast< wxSizer * >(argp1);
46875 {
46876 PyThreadState* __tstate = wxPyBeginAllowThreads();
46877 result = (PyObject *)wxSizer_GetChildren(arg1);
46878 wxPyEndAllowThreads(__tstate);
46879 if (PyErr_Occurred()) SWIG_fail;
46880 }
46881 resultobj = result;
46882 return resultobj;
46883 fail:
46884 return NULL;
46885 }
46886
46887
46888 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46889 PyObject *resultobj = 0;
46890 wxSizer *arg1 = (wxSizer *) 0 ;
46891 PyObject *arg2 = (PyObject *) 0 ;
46892 bool arg3 = (bool) true ;
46893 bool arg4 = (bool) false ;
46894 bool result;
46895 void *argp1 = 0 ;
46896 int res1 = 0 ;
46897 bool val3 ;
46898 int ecode3 = 0 ;
46899 bool val4 ;
46900 int ecode4 = 0 ;
46901 PyObject * obj0 = 0 ;
46902 PyObject * obj1 = 0 ;
46903 PyObject * obj2 = 0 ;
46904 PyObject * obj3 = 0 ;
46905 char * kwnames[] = {
46906 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
46907 };
46908
46909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
46910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46911 if (!SWIG_IsOK(res1)) {
46912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
46913 }
46914 arg1 = reinterpret_cast< wxSizer * >(argp1);
46915 arg2 = obj1;
46916 if (obj2) {
46917 ecode3 = SWIG_AsVal_bool(obj2, &val3);
46918 if (!SWIG_IsOK(ecode3)) {
46919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
46920 }
46921 arg3 = static_cast< bool >(val3);
46922 }
46923 if (obj3) {
46924 ecode4 = SWIG_AsVal_bool(obj3, &val4);
46925 if (!SWIG_IsOK(ecode4)) {
46926 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
46927 }
46928 arg4 = static_cast< bool >(val4);
46929 }
46930 {
46931 PyThreadState* __tstate = wxPyBeginAllowThreads();
46932 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
46933 wxPyEndAllowThreads(__tstate);
46934 if (PyErr_Occurred()) SWIG_fail;
46935 }
46936 {
46937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46938 }
46939 return resultobj;
46940 fail:
46941 return NULL;
46942 }
46943
46944
46945 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46946 PyObject *resultobj = 0;
46947 wxSizer *arg1 = (wxSizer *) 0 ;
46948 PyObject *arg2 = (PyObject *) 0 ;
46949 bool result;
46950 void *argp1 = 0 ;
46951 int res1 = 0 ;
46952 PyObject * obj0 = 0 ;
46953 PyObject * obj1 = 0 ;
46954 char * kwnames[] = {
46955 (char *) "self",(char *) "item", NULL
46956 };
46957
46958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
46959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46960 if (!SWIG_IsOK(res1)) {
46961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
46962 }
46963 arg1 = reinterpret_cast< wxSizer * >(argp1);
46964 arg2 = obj1;
46965 {
46966 PyThreadState* __tstate = wxPyBeginAllowThreads();
46967 result = (bool)wxSizer_IsShown(arg1,arg2);
46968 wxPyEndAllowThreads(__tstate);
46969 if (PyErr_Occurred()) SWIG_fail;
46970 }
46971 {
46972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46973 }
46974 return resultobj;
46975 fail:
46976 return NULL;
46977 }
46978
46979
46980 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46981 PyObject *resultobj = 0;
46982 wxSizer *arg1 = (wxSizer *) 0 ;
46983 bool arg2 ;
46984 void *argp1 = 0 ;
46985 int res1 = 0 ;
46986 bool val2 ;
46987 int ecode2 = 0 ;
46988 PyObject * obj0 = 0 ;
46989 PyObject * obj1 = 0 ;
46990 char * kwnames[] = {
46991 (char *) "self",(char *) "show", NULL
46992 };
46993
46994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
46995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46996 if (!SWIG_IsOK(res1)) {
46997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
46998 }
46999 arg1 = reinterpret_cast< wxSizer * >(argp1);
47000 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47001 if (!SWIG_IsOK(ecode2)) {
47002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47003 }
47004 arg2 = static_cast< bool >(val2);
47005 {
47006 PyThreadState* __tstate = wxPyBeginAllowThreads();
47007 (arg1)->ShowItems(arg2);
47008 wxPyEndAllowThreads(__tstate);
47009 if (PyErr_Occurred()) SWIG_fail;
47010 }
47011 resultobj = SWIG_Py_Void();
47012 return resultobj;
47013 fail:
47014 return NULL;
47015 }
47016
47017
47018 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47019 PyObject *obj;
47020 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47021 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47022 return SWIG_Py_Void();
47023 }
47024
47025 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47026 PyObject *resultobj = 0;
47027 wxPySizer *result = 0 ;
47028
47029 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47030 {
47031 PyThreadState* __tstate = wxPyBeginAllowThreads();
47032 result = (wxPySizer *)new wxPySizer();
47033 wxPyEndAllowThreads(__tstate);
47034 if (PyErr_Occurred()) SWIG_fail;
47035 }
47036 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47037 return resultobj;
47038 fail:
47039 return NULL;
47040 }
47041
47042
47043 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47044 PyObject *resultobj = 0;
47045 wxPySizer *arg1 = (wxPySizer *) 0 ;
47046 PyObject *arg2 = (PyObject *) 0 ;
47047 PyObject *arg3 = (PyObject *) 0 ;
47048 void *argp1 = 0 ;
47049 int res1 = 0 ;
47050 PyObject * obj0 = 0 ;
47051 PyObject * obj1 = 0 ;
47052 PyObject * obj2 = 0 ;
47053 char * kwnames[] = {
47054 (char *) "self",(char *) "self",(char *) "_class", NULL
47055 };
47056
47057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47059 if (!SWIG_IsOK(res1)) {
47060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47061 }
47062 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47063 arg2 = obj1;
47064 arg3 = obj2;
47065 {
47066 PyThreadState* __tstate = wxPyBeginAllowThreads();
47067 (arg1)->_setCallbackInfo(arg2,arg3);
47068 wxPyEndAllowThreads(__tstate);
47069 if (PyErr_Occurred()) SWIG_fail;
47070 }
47071 resultobj = SWIG_Py_Void();
47072 return resultobj;
47073 fail:
47074 return NULL;
47075 }
47076
47077
47078 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47079 PyObject *obj;
47080 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47081 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47082 return SWIG_Py_Void();
47083 }
47084
47085 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47086 return SWIG_Python_InitShadowInstance(args);
47087 }
47088
47089 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47090 PyObject *resultobj = 0;
47091 int arg1 = (int) wxHORIZONTAL ;
47092 wxBoxSizer *result = 0 ;
47093 int val1 ;
47094 int ecode1 = 0 ;
47095 PyObject * obj0 = 0 ;
47096 char * kwnames[] = {
47097 (char *) "orient", NULL
47098 };
47099
47100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47101 if (obj0) {
47102 ecode1 = SWIG_AsVal_int(obj0, &val1);
47103 if (!SWIG_IsOK(ecode1)) {
47104 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47105 }
47106 arg1 = static_cast< int >(val1);
47107 }
47108 {
47109 PyThreadState* __tstate = wxPyBeginAllowThreads();
47110 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47111 wxPyEndAllowThreads(__tstate);
47112 if (PyErr_Occurred()) SWIG_fail;
47113 }
47114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47115 return resultobj;
47116 fail:
47117 return NULL;
47118 }
47119
47120
47121 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47122 PyObject *resultobj = 0;
47123 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47124 int result;
47125 void *argp1 = 0 ;
47126 int res1 = 0 ;
47127 PyObject *swig_obj[1] ;
47128
47129 if (!args) SWIG_fail;
47130 swig_obj[0] = args;
47131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47132 if (!SWIG_IsOK(res1)) {
47133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47134 }
47135 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47136 {
47137 PyThreadState* __tstate = wxPyBeginAllowThreads();
47138 result = (int)(arg1)->GetOrientation();
47139 wxPyEndAllowThreads(__tstate);
47140 if (PyErr_Occurred()) SWIG_fail;
47141 }
47142 resultobj = SWIG_From_int(static_cast< int >(result));
47143 return resultobj;
47144 fail:
47145 return NULL;
47146 }
47147
47148
47149 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47150 PyObject *resultobj = 0;
47151 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47152 int arg2 ;
47153 void *argp1 = 0 ;
47154 int res1 = 0 ;
47155 int val2 ;
47156 int ecode2 = 0 ;
47157 PyObject * obj0 = 0 ;
47158 PyObject * obj1 = 0 ;
47159 char * kwnames[] = {
47160 (char *) "self",(char *) "orient", NULL
47161 };
47162
47163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47165 if (!SWIG_IsOK(res1)) {
47166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47167 }
47168 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47169 ecode2 = SWIG_AsVal_int(obj1, &val2);
47170 if (!SWIG_IsOK(ecode2)) {
47171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47172 }
47173 arg2 = static_cast< int >(val2);
47174 {
47175 PyThreadState* __tstate = wxPyBeginAllowThreads();
47176 (arg1)->SetOrientation(arg2);
47177 wxPyEndAllowThreads(__tstate);
47178 if (PyErr_Occurred()) SWIG_fail;
47179 }
47180 resultobj = SWIG_Py_Void();
47181 return resultobj;
47182 fail:
47183 return NULL;
47184 }
47185
47186
47187 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47188 PyObject *obj;
47189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47190 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47191 return SWIG_Py_Void();
47192 }
47193
47194 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47195 return SWIG_Python_InitShadowInstance(args);
47196 }
47197
47198 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47199 PyObject *resultobj = 0;
47200 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47201 int arg2 = (int) wxHORIZONTAL ;
47202 wxStaticBoxSizer *result = 0 ;
47203 void *argp1 = 0 ;
47204 int res1 = 0 ;
47205 int val2 ;
47206 int ecode2 = 0 ;
47207 PyObject * obj0 = 0 ;
47208 PyObject * obj1 = 0 ;
47209 char * kwnames[] = {
47210 (char *) "box",(char *) "orient", NULL
47211 };
47212
47213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47215 if (!SWIG_IsOK(res1)) {
47216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47217 }
47218 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47219 if (obj1) {
47220 ecode2 = SWIG_AsVal_int(obj1, &val2);
47221 if (!SWIG_IsOK(ecode2)) {
47222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47223 }
47224 arg2 = static_cast< int >(val2);
47225 }
47226 {
47227 PyThreadState* __tstate = wxPyBeginAllowThreads();
47228 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47229 wxPyEndAllowThreads(__tstate);
47230 if (PyErr_Occurred()) SWIG_fail;
47231 }
47232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47233 return resultobj;
47234 fail:
47235 return NULL;
47236 }
47237
47238
47239 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47240 PyObject *resultobj = 0;
47241 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47242 wxStaticBox *result = 0 ;
47243 void *argp1 = 0 ;
47244 int res1 = 0 ;
47245 PyObject *swig_obj[1] ;
47246
47247 if (!args) SWIG_fail;
47248 swig_obj[0] = args;
47249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47250 if (!SWIG_IsOK(res1)) {
47251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47252 }
47253 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47254 {
47255 PyThreadState* __tstate = wxPyBeginAllowThreads();
47256 result = (wxStaticBox *)(arg1)->GetStaticBox();
47257 wxPyEndAllowThreads(__tstate);
47258 if (PyErr_Occurred()) SWIG_fail;
47259 }
47260 {
47261 resultobj = wxPyMake_wxObject(result, (bool)0);
47262 }
47263 return resultobj;
47264 fail:
47265 return NULL;
47266 }
47267
47268
47269 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47270 PyObject *obj;
47271 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47272 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47273 return SWIG_Py_Void();
47274 }
47275
47276 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47277 return SWIG_Python_InitShadowInstance(args);
47278 }
47279
47280 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47281 PyObject *resultobj = 0;
47282 int arg1 = (int) 1 ;
47283 int arg2 = (int) 0 ;
47284 int arg3 = (int) 0 ;
47285 int arg4 = (int) 0 ;
47286 wxGridSizer *result = 0 ;
47287 int val1 ;
47288 int ecode1 = 0 ;
47289 int val2 ;
47290 int ecode2 = 0 ;
47291 int val3 ;
47292 int ecode3 = 0 ;
47293 int val4 ;
47294 int ecode4 = 0 ;
47295 PyObject * obj0 = 0 ;
47296 PyObject * obj1 = 0 ;
47297 PyObject * obj2 = 0 ;
47298 PyObject * obj3 = 0 ;
47299 char * kwnames[] = {
47300 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47301 };
47302
47303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47304 if (obj0) {
47305 ecode1 = SWIG_AsVal_int(obj0, &val1);
47306 if (!SWIG_IsOK(ecode1)) {
47307 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47308 }
47309 arg1 = static_cast< int >(val1);
47310 }
47311 if (obj1) {
47312 ecode2 = SWIG_AsVal_int(obj1, &val2);
47313 if (!SWIG_IsOK(ecode2)) {
47314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47315 }
47316 arg2 = static_cast< int >(val2);
47317 }
47318 if (obj2) {
47319 ecode3 = SWIG_AsVal_int(obj2, &val3);
47320 if (!SWIG_IsOK(ecode3)) {
47321 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47322 }
47323 arg3 = static_cast< int >(val3);
47324 }
47325 if (obj3) {
47326 ecode4 = SWIG_AsVal_int(obj3, &val4);
47327 if (!SWIG_IsOK(ecode4)) {
47328 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47329 }
47330 arg4 = static_cast< int >(val4);
47331 }
47332 {
47333 PyThreadState* __tstate = wxPyBeginAllowThreads();
47334 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47335 wxPyEndAllowThreads(__tstate);
47336 if (PyErr_Occurred()) SWIG_fail;
47337 }
47338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47339 return resultobj;
47340 fail:
47341 return NULL;
47342 }
47343
47344
47345 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47346 PyObject *resultobj = 0;
47347 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47348 int arg2 ;
47349 void *argp1 = 0 ;
47350 int res1 = 0 ;
47351 int val2 ;
47352 int ecode2 = 0 ;
47353 PyObject * obj0 = 0 ;
47354 PyObject * obj1 = 0 ;
47355 char * kwnames[] = {
47356 (char *) "self",(char *) "cols", NULL
47357 };
47358
47359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47361 if (!SWIG_IsOK(res1)) {
47362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47363 }
47364 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47365 ecode2 = SWIG_AsVal_int(obj1, &val2);
47366 if (!SWIG_IsOK(ecode2)) {
47367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47368 }
47369 arg2 = static_cast< int >(val2);
47370 {
47371 PyThreadState* __tstate = wxPyBeginAllowThreads();
47372 (arg1)->SetCols(arg2);
47373 wxPyEndAllowThreads(__tstate);
47374 if (PyErr_Occurred()) SWIG_fail;
47375 }
47376 resultobj = SWIG_Py_Void();
47377 return resultobj;
47378 fail:
47379 return NULL;
47380 }
47381
47382
47383 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47384 PyObject *resultobj = 0;
47385 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47386 int arg2 ;
47387 void *argp1 = 0 ;
47388 int res1 = 0 ;
47389 int val2 ;
47390 int ecode2 = 0 ;
47391 PyObject * obj0 = 0 ;
47392 PyObject * obj1 = 0 ;
47393 char * kwnames[] = {
47394 (char *) "self",(char *) "rows", NULL
47395 };
47396
47397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47399 if (!SWIG_IsOK(res1)) {
47400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47401 }
47402 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47403 ecode2 = SWIG_AsVal_int(obj1, &val2);
47404 if (!SWIG_IsOK(ecode2)) {
47405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47406 }
47407 arg2 = static_cast< int >(val2);
47408 {
47409 PyThreadState* __tstate = wxPyBeginAllowThreads();
47410 (arg1)->SetRows(arg2);
47411 wxPyEndAllowThreads(__tstate);
47412 if (PyErr_Occurred()) SWIG_fail;
47413 }
47414 resultobj = SWIG_Py_Void();
47415 return resultobj;
47416 fail:
47417 return NULL;
47418 }
47419
47420
47421 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47422 PyObject *resultobj = 0;
47423 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47424 int arg2 ;
47425 void *argp1 = 0 ;
47426 int res1 = 0 ;
47427 int val2 ;
47428 int ecode2 = 0 ;
47429 PyObject * obj0 = 0 ;
47430 PyObject * obj1 = 0 ;
47431 char * kwnames[] = {
47432 (char *) "self",(char *) "gap", NULL
47433 };
47434
47435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47437 if (!SWIG_IsOK(res1)) {
47438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47439 }
47440 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47441 ecode2 = SWIG_AsVal_int(obj1, &val2);
47442 if (!SWIG_IsOK(ecode2)) {
47443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47444 }
47445 arg2 = static_cast< int >(val2);
47446 {
47447 PyThreadState* __tstate = wxPyBeginAllowThreads();
47448 (arg1)->SetVGap(arg2);
47449 wxPyEndAllowThreads(__tstate);
47450 if (PyErr_Occurred()) SWIG_fail;
47451 }
47452 resultobj = SWIG_Py_Void();
47453 return resultobj;
47454 fail:
47455 return NULL;
47456 }
47457
47458
47459 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47460 PyObject *resultobj = 0;
47461 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47462 int arg2 ;
47463 void *argp1 = 0 ;
47464 int res1 = 0 ;
47465 int val2 ;
47466 int ecode2 = 0 ;
47467 PyObject * obj0 = 0 ;
47468 PyObject * obj1 = 0 ;
47469 char * kwnames[] = {
47470 (char *) "self",(char *) "gap", NULL
47471 };
47472
47473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47475 if (!SWIG_IsOK(res1)) {
47476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47477 }
47478 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47479 ecode2 = SWIG_AsVal_int(obj1, &val2);
47480 if (!SWIG_IsOK(ecode2)) {
47481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47482 }
47483 arg2 = static_cast< int >(val2);
47484 {
47485 PyThreadState* __tstate = wxPyBeginAllowThreads();
47486 (arg1)->SetHGap(arg2);
47487 wxPyEndAllowThreads(__tstate);
47488 if (PyErr_Occurred()) SWIG_fail;
47489 }
47490 resultobj = SWIG_Py_Void();
47491 return resultobj;
47492 fail:
47493 return NULL;
47494 }
47495
47496
47497 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47498 PyObject *resultobj = 0;
47499 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47500 int result;
47501 void *argp1 = 0 ;
47502 int res1 = 0 ;
47503 PyObject *swig_obj[1] ;
47504
47505 if (!args) SWIG_fail;
47506 swig_obj[0] = args;
47507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47508 if (!SWIG_IsOK(res1)) {
47509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47510 }
47511 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47512 {
47513 PyThreadState* __tstate = wxPyBeginAllowThreads();
47514 result = (int)(arg1)->GetCols();
47515 wxPyEndAllowThreads(__tstate);
47516 if (PyErr_Occurred()) SWIG_fail;
47517 }
47518 resultobj = SWIG_From_int(static_cast< int >(result));
47519 return resultobj;
47520 fail:
47521 return NULL;
47522 }
47523
47524
47525 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47526 PyObject *resultobj = 0;
47527 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47528 int result;
47529 void *argp1 = 0 ;
47530 int res1 = 0 ;
47531 PyObject *swig_obj[1] ;
47532
47533 if (!args) SWIG_fail;
47534 swig_obj[0] = args;
47535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47536 if (!SWIG_IsOK(res1)) {
47537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47538 }
47539 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47540 {
47541 PyThreadState* __tstate = wxPyBeginAllowThreads();
47542 result = (int)(arg1)->GetRows();
47543 wxPyEndAllowThreads(__tstate);
47544 if (PyErr_Occurred()) SWIG_fail;
47545 }
47546 resultobj = SWIG_From_int(static_cast< int >(result));
47547 return resultobj;
47548 fail:
47549 return NULL;
47550 }
47551
47552
47553 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47554 PyObject *resultobj = 0;
47555 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47556 int result;
47557 void *argp1 = 0 ;
47558 int res1 = 0 ;
47559 PyObject *swig_obj[1] ;
47560
47561 if (!args) SWIG_fail;
47562 swig_obj[0] = args;
47563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47564 if (!SWIG_IsOK(res1)) {
47565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47566 }
47567 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47568 {
47569 PyThreadState* __tstate = wxPyBeginAllowThreads();
47570 result = (int)(arg1)->GetVGap();
47571 wxPyEndAllowThreads(__tstate);
47572 if (PyErr_Occurred()) SWIG_fail;
47573 }
47574 resultobj = SWIG_From_int(static_cast< int >(result));
47575 return resultobj;
47576 fail:
47577 return NULL;
47578 }
47579
47580
47581 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47582 PyObject *resultobj = 0;
47583 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47584 int result;
47585 void *argp1 = 0 ;
47586 int res1 = 0 ;
47587 PyObject *swig_obj[1] ;
47588
47589 if (!args) SWIG_fail;
47590 swig_obj[0] = args;
47591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47592 if (!SWIG_IsOK(res1)) {
47593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47594 }
47595 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47596 {
47597 PyThreadState* __tstate = wxPyBeginAllowThreads();
47598 result = (int)(arg1)->GetHGap();
47599 wxPyEndAllowThreads(__tstate);
47600 if (PyErr_Occurred()) SWIG_fail;
47601 }
47602 resultobj = SWIG_From_int(static_cast< int >(result));
47603 return resultobj;
47604 fail:
47605 return NULL;
47606 }
47607
47608
47609 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47610 PyObject *obj;
47611 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47612 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47613 return SWIG_Py_Void();
47614 }
47615
47616 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47617 return SWIG_Python_InitShadowInstance(args);
47618 }
47619
47620 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47621 PyObject *resultobj = 0;
47622 int arg1 = (int) 1 ;
47623 int arg2 = (int) 0 ;
47624 int arg3 = (int) 0 ;
47625 int arg4 = (int) 0 ;
47626 wxFlexGridSizer *result = 0 ;
47627 int val1 ;
47628 int ecode1 = 0 ;
47629 int val2 ;
47630 int ecode2 = 0 ;
47631 int val3 ;
47632 int ecode3 = 0 ;
47633 int val4 ;
47634 int ecode4 = 0 ;
47635 PyObject * obj0 = 0 ;
47636 PyObject * obj1 = 0 ;
47637 PyObject * obj2 = 0 ;
47638 PyObject * obj3 = 0 ;
47639 char * kwnames[] = {
47640 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47641 };
47642
47643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47644 if (obj0) {
47645 ecode1 = SWIG_AsVal_int(obj0, &val1);
47646 if (!SWIG_IsOK(ecode1)) {
47647 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47648 }
47649 arg1 = static_cast< int >(val1);
47650 }
47651 if (obj1) {
47652 ecode2 = SWIG_AsVal_int(obj1, &val2);
47653 if (!SWIG_IsOK(ecode2)) {
47654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47655 }
47656 arg2 = static_cast< int >(val2);
47657 }
47658 if (obj2) {
47659 ecode3 = SWIG_AsVal_int(obj2, &val3);
47660 if (!SWIG_IsOK(ecode3)) {
47661 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47662 }
47663 arg3 = static_cast< int >(val3);
47664 }
47665 if (obj3) {
47666 ecode4 = SWIG_AsVal_int(obj3, &val4);
47667 if (!SWIG_IsOK(ecode4)) {
47668 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47669 }
47670 arg4 = static_cast< int >(val4);
47671 }
47672 {
47673 PyThreadState* __tstate = wxPyBeginAllowThreads();
47674 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47675 wxPyEndAllowThreads(__tstate);
47676 if (PyErr_Occurred()) SWIG_fail;
47677 }
47678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47679 return resultobj;
47680 fail:
47681 return NULL;
47682 }
47683
47684
47685 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47686 PyObject *resultobj = 0;
47687 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47688 size_t arg2 ;
47689 int arg3 = (int) 0 ;
47690 void *argp1 = 0 ;
47691 int res1 = 0 ;
47692 size_t val2 ;
47693 int ecode2 = 0 ;
47694 int val3 ;
47695 int ecode3 = 0 ;
47696 PyObject * obj0 = 0 ;
47697 PyObject * obj1 = 0 ;
47698 PyObject * obj2 = 0 ;
47699 char * kwnames[] = {
47700 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47701 };
47702
47703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47705 if (!SWIG_IsOK(res1)) {
47706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47707 }
47708 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47709 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47710 if (!SWIG_IsOK(ecode2)) {
47711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47712 }
47713 arg2 = static_cast< size_t >(val2);
47714 if (obj2) {
47715 ecode3 = SWIG_AsVal_int(obj2, &val3);
47716 if (!SWIG_IsOK(ecode3)) {
47717 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47718 }
47719 arg3 = static_cast< int >(val3);
47720 }
47721 {
47722 PyThreadState* __tstate = wxPyBeginAllowThreads();
47723 (arg1)->AddGrowableRow(arg2,arg3);
47724 wxPyEndAllowThreads(__tstate);
47725 if (PyErr_Occurred()) SWIG_fail;
47726 }
47727 resultobj = SWIG_Py_Void();
47728 return resultobj;
47729 fail:
47730 return NULL;
47731 }
47732
47733
47734 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47735 PyObject *resultobj = 0;
47736 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47737 size_t arg2 ;
47738 void *argp1 = 0 ;
47739 int res1 = 0 ;
47740 size_t val2 ;
47741 int ecode2 = 0 ;
47742 PyObject * obj0 = 0 ;
47743 PyObject * obj1 = 0 ;
47744 char * kwnames[] = {
47745 (char *) "self",(char *) "idx", NULL
47746 };
47747
47748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
47749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47750 if (!SWIG_IsOK(res1)) {
47751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47752 }
47753 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47754 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47755 if (!SWIG_IsOK(ecode2)) {
47756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47757 }
47758 arg2 = static_cast< size_t >(val2);
47759 {
47760 PyThreadState* __tstate = wxPyBeginAllowThreads();
47761 (arg1)->RemoveGrowableRow(arg2);
47762 wxPyEndAllowThreads(__tstate);
47763 if (PyErr_Occurred()) SWIG_fail;
47764 }
47765 resultobj = SWIG_Py_Void();
47766 return resultobj;
47767 fail:
47768 return NULL;
47769 }
47770
47771
47772 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47773 PyObject *resultobj = 0;
47774 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47775 size_t arg2 ;
47776 int arg3 = (int) 0 ;
47777 void *argp1 = 0 ;
47778 int res1 = 0 ;
47779 size_t val2 ;
47780 int ecode2 = 0 ;
47781 int val3 ;
47782 int ecode3 = 0 ;
47783 PyObject * obj0 = 0 ;
47784 PyObject * obj1 = 0 ;
47785 PyObject * obj2 = 0 ;
47786 char * kwnames[] = {
47787 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47788 };
47789
47790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47792 if (!SWIG_IsOK(res1)) {
47793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47794 }
47795 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47796 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47797 if (!SWIG_IsOK(ecode2)) {
47798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47799 }
47800 arg2 = static_cast< size_t >(val2);
47801 if (obj2) {
47802 ecode3 = SWIG_AsVal_int(obj2, &val3);
47803 if (!SWIG_IsOK(ecode3)) {
47804 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
47805 }
47806 arg3 = static_cast< int >(val3);
47807 }
47808 {
47809 PyThreadState* __tstate = wxPyBeginAllowThreads();
47810 (arg1)->AddGrowableCol(arg2,arg3);
47811 wxPyEndAllowThreads(__tstate);
47812 if (PyErr_Occurred()) SWIG_fail;
47813 }
47814 resultobj = SWIG_Py_Void();
47815 return resultobj;
47816 fail:
47817 return NULL;
47818 }
47819
47820
47821 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47822 PyObject *resultobj = 0;
47823 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47824 size_t arg2 ;
47825 void *argp1 = 0 ;
47826 int res1 = 0 ;
47827 size_t val2 ;
47828 int ecode2 = 0 ;
47829 PyObject * obj0 = 0 ;
47830 PyObject * obj1 = 0 ;
47831 char * kwnames[] = {
47832 (char *) "self",(char *) "idx", NULL
47833 };
47834
47835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
47836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47837 if (!SWIG_IsOK(res1)) {
47838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47839 }
47840 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47841 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47842 if (!SWIG_IsOK(ecode2)) {
47843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47844 }
47845 arg2 = static_cast< size_t >(val2);
47846 {
47847 PyThreadState* __tstate = wxPyBeginAllowThreads();
47848 (arg1)->RemoveGrowableCol(arg2);
47849 wxPyEndAllowThreads(__tstate);
47850 if (PyErr_Occurred()) SWIG_fail;
47851 }
47852 resultobj = SWIG_Py_Void();
47853 return resultobj;
47854 fail:
47855 return NULL;
47856 }
47857
47858
47859 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47860 PyObject *resultobj = 0;
47861 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47862 int arg2 ;
47863 void *argp1 = 0 ;
47864 int res1 = 0 ;
47865 int val2 ;
47866 int ecode2 = 0 ;
47867 PyObject * obj0 = 0 ;
47868 PyObject * obj1 = 0 ;
47869 char * kwnames[] = {
47870 (char *) "self",(char *) "direction", NULL
47871 };
47872
47873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
47874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47875 if (!SWIG_IsOK(res1)) {
47876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47877 }
47878 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47879 ecode2 = SWIG_AsVal_int(obj1, &val2);
47880 if (!SWIG_IsOK(ecode2)) {
47881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
47882 }
47883 arg2 = static_cast< int >(val2);
47884 {
47885 PyThreadState* __tstate = wxPyBeginAllowThreads();
47886 (arg1)->SetFlexibleDirection(arg2);
47887 wxPyEndAllowThreads(__tstate);
47888 if (PyErr_Occurred()) SWIG_fail;
47889 }
47890 resultobj = SWIG_Py_Void();
47891 return resultobj;
47892 fail:
47893 return NULL;
47894 }
47895
47896
47897 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47898 PyObject *resultobj = 0;
47899 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47900 int result;
47901 void *argp1 = 0 ;
47902 int res1 = 0 ;
47903 PyObject *swig_obj[1] ;
47904
47905 if (!args) SWIG_fail;
47906 swig_obj[0] = args;
47907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47908 if (!SWIG_IsOK(res1)) {
47909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47910 }
47911 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47912 {
47913 PyThreadState* __tstate = wxPyBeginAllowThreads();
47914 result = (int)(arg1)->GetFlexibleDirection();
47915 wxPyEndAllowThreads(__tstate);
47916 if (PyErr_Occurred()) SWIG_fail;
47917 }
47918 resultobj = SWIG_From_int(static_cast< int >(result));
47919 return resultobj;
47920 fail:
47921 return NULL;
47922 }
47923
47924
47925 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47926 PyObject *resultobj = 0;
47927 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47928 wxFlexSizerGrowMode arg2 ;
47929 void *argp1 = 0 ;
47930 int res1 = 0 ;
47931 int val2 ;
47932 int ecode2 = 0 ;
47933 PyObject * obj0 = 0 ;
47934 PyObject * obj1 = 0 ;
47935 char * kwnames[] = {
47936 (char *) "self",(char *) "mode", NULL
47937 };
47938
47939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
47940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47941 if (!SWIG_IsOK(res1)) {
47942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47943 }
47944 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47945 ecode2 = SWIG_AsVal_int(obj1, &val2);
47946 if (!SWIG_IsOK(ecode2)) {
47947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
47948 }
47949 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
47950 {
47951 PyThreadState* __tstate = wxPyBeginAllowThreads();
47952 (arg1)->SetNonFlexibleGrowMode(arg2);
47953 wxPyEndAllowThreads(__tstate);
47954 if (PyErr_Occurred()) SWIG_fail;
47955 }
47956 resultobj = SWIG_Py_Void();
47957 return resultobj;
47958 fail:
47959 return NULL;
47960 }
47961
47962
47963 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47964 PyObject *resultobj = 0;
47965 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47966 wxFlexSizerGrowMode result;
47967 void *argp1 = 0 ;
47968 int res1 = 0 ;
47969 PyObject *swig_obj[1] ;
47970
47971 if (!args) SWIG_fail;
47972 swig_obj[0] = args;
47973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47974 if (!SWIG_IsOK(res1)) {
47975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47976 }
47977 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47978 {
47979 PyThreadState* __tstate = wxPyBeginAllowThreads();
47980 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
47981 wxPyEndAllowThreads(__tstate);
47982 if (PyErr_Occurred()) SWIG_fail;
47983 }
47984 resultobj = SWIG_From_int(static_cast< int >(result));
47985 return resultobj;
47986 fail:
47987 return NULL;
47988 }
47989
47990
47991 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47992 PyObject *resultobj = 0;
47993 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47994 wxArrayInt *result = 0 ;
47995 void *argp1 = 0 ;
47996 int res1 = 0 ;
47997 PyObject *swig_obj[1] ;
47998
47999 if (!args) SWIG_fail;
48000 swig_obj[0] = args;
48001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48002 if (!SWIG_IsOK(res1)) {
48003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48004 }
48005 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48006 {
48007 PyThreadState* __tstate = wxPyBeginAllowThreads();
48008 {
48009 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48010 result = (wxArrayInt *) &_result_ref;
48011 }
48012 wxPyEndAllowThreads(__tstate);
48013 if (PyErr_Occurred()) SWIG_fail;
48014 }
48015 {
48016 resultobj = PyList_New(0);
48017 size_t idx;
48018 for (idx = 0; idx < result->GetCount(); idx += 1) {
48019 PyObject* val = PyInt_FromLong( result->Item(idx) );
48020 PyList_Append(resultobj, val);
48021 Py_DECREF(val);
48022 }
48023 }
48024 return resultobj;
48025 fail:
48026 return NULL;
48027 }
48028
48029
48030 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48031 PyObject *resultobj = 0;
48032 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48033 wxArrayInt *result = 0 ;
48034 void *argp1 = 0 ;
48035 int res1 = 0 ;
48036 PyObject *swig_obj[1] ;
48037
48038 if (!args) SWIG_fail;
48039 swig_obj[0] = args;
48040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48041 if (!SWIG_IsOK(res1)) {
48042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48043 }
48044 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48045 {
48046 PyThreadState* __tstate = wxPyBeginAllowThreads();
48047 {
48048 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48049 result = (wxArrayInt *) &_result_ref;
48050 }
48051 wxPyEndAllowThreads(__tstate);
48052 if (PyErr_Occurred()) SWIG_fail;
48053 }
48054 {
48055 resultobj = PyList_New(0);
48056 size_t idx;
48057 for (idx = 0; idx < result->GetCount(); idx += 1) {
48058 PyObject* val = PyInt_FromLong( result->Item(idx) );
48059 PyList_Append(resultobj, val);
48060 Py_DECREF(val);
48061 }
48062 }
48063 return resultobj;
48064 fail:
48065 return NULL;
48066 }
48067
48068
48069 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48070 PyObject *obj;
48071 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48072 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48073 return SWIG_Py_Void();
48074 }
48075
48076 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48077 return SWIG_Python_InitShadowInstance(args);
48078 }
48079
48080 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48081 PyObject *resultobj = 0;
48082 wxStdDialogButtonSizer *result = 0 ;
48083
48084 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48085 {
48086 PyThreadState* __tstate = wxPyBeginAllowThreads();
48087 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48088 wxPyEndAllowThreads(__tstate);
48089 if (PyErr_Occurred()) SWIG_fail;
48090 }
48091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48092 return resultobj;
48093 fail:
48094 return NULL;
48095 }
48096
48097
48098 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48099 PyObject *resultobj = 0;
48100 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48101 wxButton *arg2 = (wxButton *) 0 ;
48102 void *argp1 = 0 ;
48103 int res1 = 0 ;
48104 void *argp2 = 0 ;
48105 int res2 = 0 ;
48106 PyObject * obj0 = 0 ;
48107 PyObject * obj1 = 0 ;
48108 char * kwnames[] = {
48109 (char *) "self",(char *) "button", NULL
48110 };
48111
48112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48114 if (!SWIG_IsOK(res1)) {
48115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48116 }
48117 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48118 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48119 if (!SWIG_IsOK(res2)) {
48120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48121 }
48122 arg2 = reinterpret_cast< wxButton * >(argp2);
48123 {
48124 PyThreadState* __tstate = wxPyBeginAllowThreads();
48125 (arg1)->AddButton(arg2);
48126 wxPyEndAllowThreads(__tstate);
48127 if (PyErr_Occurred()) SWIG_fail;
48128 }
48129 resultobj = SWIG_Py_Void();
48130 return resultobj;
48131 fail:
48132 return NULL;
48133 }
48134
48135
48136 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48137 PyObject *resultobj = 0;
48138 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48139 void *argp1 = 0 ;
48140 int res1 = 0 ;
48141 PyObject *swig_obj[1] ;
48142
48143 if (!args) SWIG_fail;
48144 swig_obj[0] = args;
48145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48146 if (!SWIG_IsOK(res1)) {
48147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48148 }
48149 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48150 {
48151 PyThreadState* __tstate = wxPyBeginAllowThreads();
48152 (arg1)->Realize();
48153 wxPyEndAllowThreads(__tstate);
48154 if (PyErr_Occurred()) SWIG_fail;
48155 }
48156 resultobj = SWIG_Py_Void();
48157 return resultobj;
48158 fail:
48159 return NULL;
48160 }
48161
48162
48163 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48164 PyObject *resultobj = 0;
48165 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48166 wxButton *arg2 = (wxButton *) 0 ;
48167 void *argp1 = 0 ;
48168 int res1 = 0 ;
48169 void *argp2 = 0 ;
48170 int res2 = 0 ;
48171 PyObject * obj0 = 0 ;
48172 PyObject * obj1 = 0 ;
48173 char * kwnames[] = {
48174 (char *) "self",(char *) "button", NULL
48175 };
48176
48177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48179 if (!SWIG_IsOK(res1)) {
48180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48181 }
48182 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48183 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48184 if (!SWIG_IsOK(res2)) {
48185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48186 }
48187 arg2 = reinterpret_cast< wxButton * >(argp2);
48188 {
48189 PyThreadState* __tstate = wxPyBeginAllowThreads();
48190 (arg1)->SetAffirmativeButton(arg2);
48191 wxPyEndAllowThreads(__tstate);
48192 if (PyErr_Occurred()) SWIG_fail;
48193 }
48194 resultobj = SWIG_Py_Void();
48195 return resultobj;
48196 fail:
48197 return NULL;
48198 }
48199
48200
48201 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48202 PyObject *resultobj = 0;
48203 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48204 wxButton *arg2 = (wxButton *) 0 ;
48205 void *argp1 = 0 ;
48206 int res1 = 0 ;
48207 void *argp2 = 0 ;
48208 int res2 = 0 ;
48209 PyObject * obj0 = 0 ;
48210 PyObject * obj1 = 0 ;
48211 char * kwnames[] = {
48212 (char *) "self",(char *) "button", NULL
48213 };
48214
48215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48217 if (!SWIG_IsOK(res1)) {
48218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48219 }
48220 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48221 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48222 if (!SWIG_IsOK(res2)) {
48223 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48224 }
48225 arg2 = reinterpret_cast< wxButton * >(argp2);
48226 {
48227 PyThreadState* __tstate = wxPyBeginAllowThreads();
48228 (arg1)->SetNegativeButton(arg2);
48229 wxPyEndAllowThreads(__tstate);
48230 if (PyErr_Occurred()) SWIG_fail;
48231 }
48232 resultobj = SWIG_Py_Void();
48233 return resultobj;
48234 fail:
48235 return NULL;
48236 }
48237
48238
48239 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48240 PyObject *resultobj = 0;
48241 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48242 wxButton *arg2 = (wxButton *) 0 ;
48243 void *argp1 = 0 ;
48244 int res1 = 0 ;
48245 void *argp2 = 0 ;
48246 int res2 = 0 ;
48247 PyObject * obj0 = 0 ;
48248 PyObject * obj1 = 0 ;
48249 char * kwnames[] = {
48250 (char *) "self",(char *) "button", NULL
48251 };
48252
48253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48255 if (!SWIG_IsOK(res1)) {
48256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48257 }
48258 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48259 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48260 if (!SWIG_IsOK(res2)) {
48261 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48262 }
48263 arg2 = reinterpret_cast< wxButton * >(argp2);
48264 {
48265 PyThreadState* __tstate = wxPyBeginAllowThreads();
48266 (arg1)->SetCancelButton(arg2);
48267 wxPyEndAllowThreads(__tstate);
48268 if (PyErr_Occurred()) SWIG_fail;
48269 }
48270 resultobj = SWIG_Py_Void();
48271 return resultobj;
48272 fail:
48273 return NULL;
48274 }
48275
48276
48277 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48278 PyObject *resultobj = 0;
48279 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48280 wxButton *result = 0 ;
48281 void *argp1 = 0 ;
48282 int res1 = 0 ;
48283 PyObject *swig_obj[1] ;
48284
48285 if (!args) SWIG_fail;
48286 swig_obj[0] = args;
48287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48288 if (!SWIG_IsOK(res1)) {
48289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48290 }
48291 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48292 {
48293 PyThreadState* __tstate = wxPyBeginAllowThreads();
48294 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48295 wxPyEndAllowThreads(__tstate);
48296 if (PyErr_Occurred()) SWIG_fail;
48297 }
48298 {
48299 resultobj = wxPyMake_wxObject(result, (bool)0);
48300 }
48301 return resultobj;
48302 fail:
48303 return NULL;
48304 }
48305
48306
48307 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48308 PyObject *resultobj = 0;
48309 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48310 wxButton *result = 0 ;
48311 void *argp1 = 0 ;
48312 int res1 = 0 ;
48313 PyObject *swig_obj[1] ;
48314
48315 if (!args) SWIG_fail;
48316 swig_obj[0] = args;
48317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48318 if (!SWIG_IsOK(res1)) {
48319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48320 }
48321 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48322 {
48323 PyThreadState* __tstate = wxPyBeginAllowThreads();
48324 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48325 wxPyEndAllowThreads(__tstate);
48326 if (PyErr_Occurred()) SWIG_fail;
48327 }
48328 {
48329 resultobj = wxPyMake_wxObject(result, (bool)0);
48330 }
48331 return resultobj;
48332 fail:
48333 return NULL;
48334 }
48335
48336
48337 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48338 PyObject *resultobj = 0;
48339 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48340 wxButton *result = 0 ;
48341 void *argp1 = 0 ;
48342 int res1 = 0 ;
48343 PyObject *swig_obj[1] ;
48344
48345 if (!args) SWIG_fail;
48346 swig_obj[0] = args;
48347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48348 if (!SWIG_IsOK(res1)) {
48349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48350 }
48351 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48352 {
48353 PyThreadState* __tstate = wxPyBeginAllowThreads();
48354 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48355 wxPyEndAllowThreads(__tstate);
48356 if (PyErr_Occurred()) SWIG_fail;
48357 }
48358 {
48359 resultobj = wxPyMake_wxObject(result, (bool)0);
48360 }
48361 return resultobj;
48362 fail:
48363 return NULL;
48364 }
48365
48366
48367 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48368 PyObject *resultobj = 0;
48369 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48370 wxButton *result = 0 ;
48371 void *argp1 = 0 ;
48372 int res1 = 0 ;
48373 PyObject *swig_obj[1] ;
48374
48375 if (!args) SWIG_fail;
48376 swig_obj[0] = args;
48377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48378 if (!SWIG_IsOK(res1)) {
48379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48380 }
48381 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48382 {
48383 PyThreadState* __tstate = wxPyBeginAllowThreads();
48384 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48385 wxPyEndAllowThreads(__tstate);
48386 if (PyErr_Occurred()) SWIG_fail;
48387 }
48388 {
48389 resultobj = wxPyMake_wxObject(result, (bool)0);
48390 }
48391 return resultobj;
48392 fail:
48393 return NULL;
48394 }
48395
48396
48397 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48398 PyObject *resultobj = 0;
48399 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48400 wxButton *result = 0 ;
48401 void *argp1 = 0 ;
48402 int res1 = 0 ;
48403 PyObject *swig_obj[1] ;
48404
48405 if (!args) SWIG_fail;
48406 swig_obj[0] = args;
48407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48408 if (!SWIG_IsOK(res1)) {
48409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48410 }
48411 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48412 {
48413 PyThreadState* __tstate = wxPyBeginAllowThreads();
48414 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48415 wxPyEndAllowThreads(__tstate);
48416 if (PyErr_Occurred()) SWIG_fail;
48417 }
48418 {
48419 resultobj = wxPyMake_wxObject(result, (bool)0);
48420 }
48421 return resultobj;
48422 fail:
48423 return NULL;
48424 }
48425
48426
48427 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48428 PyObject *obj;
48429 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48430 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48431 return SWIG_Py_Void();
48432 }
48433
48434 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48435 return SWIG_Python_InitShadowInstance(args);
48436 }
48437
48438 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48439 PyObject *resultobj = 0;
48440 int arg1 = (int) 0 ;
48441 int arg2 = (int) 0 ;
48442 wxGBPosition *result = 0 ;
48443 int val1 ;
48444 int ecode1 = 0 ;
48445 int val2 ;
48446 int ecode2 = 0 ;
48447 PyObject * obj0 = 0 ;
48448 PyObject * obj1 = 0 ;
48449 char * kwnames[] = {
48450 (char *) "row",(char *) "col", NULL
48451 };
48452
48453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48454 if (obj0) {
48455 ecode1 = SWIG_AsVal_int(obj0, &val1);
48456 if (!SWIG_IsOK(ecode1)) {
48457 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48458 }
48459 arg1 = static_cast< int >(val1);
48460 }
48461 if (obj1) {
48462 ecode2 = SWIG_AsVal_int(obj1, &val2);
48463 if (!SWIG_IsOK(ecode2)) {
48464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48465 }
48466 arg2 = static_cast< int >(val2);
48467 }
48468 {
48469 PyThreadState* __tstate = wxPyBeginAllowThreads();
48470 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48471 wxPyEndAllowThreads(__tstate);
48472 if (PyErr_Occurred()) SWIG_fail;
48473 }
48474 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48475 return resultobj;
48476 fail:
48477 return NULL;
48478 }
48479
48480
48481 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48482 PyObject *resultobj = 0;
48483 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48484 void *argp1 = 0 ;
48485 int res1 = 0 ;
48486 PyObject *swig_obj[1] ;
48487
48488 if (!args) SWIG_fail;
48489 swig_obj[0] = args;
48490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48491 if (!SWIG_IsOK(res1)) {
48492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48493 }
48494 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48495 {
48496 PyThreadState* __tstate = wxPyBeginAllowThreads();
48497 delete arg1;
48498
48499 wxPyEndAllowThreads(__tstate);
48500 if (PyErr_Occurred()) SWIG_fail;
48501 }
48502 resultobj = SWIG_Py_Void();
48503 return resultobj;
48504 fail:
48505 return NULL;
48506 }
48507
48508
48509 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48510 PyObject *resultobj = 0;
48511 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48512 int result;
48513 void *argp1 = 0 ;
48514 int res1 = 0 ;
48515 PyObject *swig_obj[1] ;
48516
48517 if (!args) SWIG_fail;
48518 swig_obj[0] = args;
48519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48520 if (!SWIG_IsOK(res1)) {
48521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48522 }
48523 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48524 {
48525 PyThreadState* __tstate = wxPyBeginAllowThreads();
48526 result = (int)((wxGBPosition const *)arg1)->GetRow();
48527 wxPyEndAllowThreads(__tstate);
48528 if (PyErr_Occurred()) SWIG_fail;
48529 }
48530 resultobj = SWIG_From_int(static_cast< int >(result));
48531 return resultobj;
48532 fail:
48533 return NULL;
48534 }
48535
48536
48537 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48538 PyObject *resultobj = 0;
48539 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48540 int result;
48541 void *argp1 = 0 ;
48542 int res1 = 0 ;
48543 PyObject *swig_obj[1] ;
48544
48545 if (!args) SWIG_fail;
48546 swig_obj[0] = args;
48547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48548 if (!SWIG_IsOK(res1)) {
48549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48550 }
48551 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48552 {
48553 PyThreadState* __tstate = wxPyBeginAllowThreads();
48554 result = (int)((wxGBPosition const *)arg1)->GetCol();
48555 wxPyEndAllowThreads(__tstate);
48556 if (PyErr_Occurred()) SWIG_fail;
48557 }
48558 resultobj = SWIG_From_int(static_cast< int >(result));
48559 return resultobj;
48560 fail:
48561 return NULL;
48562 }
48563
48564
48565 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48566 PyObject *resultobj = 0;
48567 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48568 int arg2 ;
48569 void *argp1 = 0 ;
48570 int res1 = 0 ;
48571 int val2 ;
48572 int ecode2 = 0 ;
48573 PyObject * obj0 = 0 ;
48574 PyObject * obj1 = 0 ;
48575 char * kwnames[] = {
48576 (char *) "self",(char *) "row", NULL
48577 };
48578
48579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48581 if (!SWIG_IsOK(res1)) {
48582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48583 }
48584 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48585 ecode2 = SWIG_AsVal_int(obj1, &val2);
48586 if (!SWIG_IsOK(ecode2)) {
48587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48588 }
48589 arg2 = static_cast< int >(val2);
48590 {
48591 PyThreadState* __tstate = wxPyBeginAllowThreads();
48592 (arg1)->SetRow(arg2);
48593 wxPyEndAllowThreads(__tstate);
48594 if (PyErr_Occurred()) SWIG_fail;
48595 }
48596 resultobj = SWIG_Py_Void();
48597 return resultobj;
48598 fail:
48599 return NULL;
48600 }
48601
48602
48603 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48604 PyObject *resultobj = 0;
48605 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48606 int arg2 ;
48607 void *argp1 = 0 ;
48608 int res1 = 0 ;
48609 int val2 ;
48610 int ecode2 = 0 ;
48611 PyObject * obj0 = 0 ;
48612 PyObject * obj1 = 0 ;
48613 char * kwnames[] = {
48614 (char *) "self",(char *) "col", NULL
48615 };
48616
48617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48619 if (!SWIG_IsOK(res1)) {
48620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48621 }
48622 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48623 ecode2 = SWIG_AsVal_int(obj1, &val2);
48624 if (!SWIG_IsOK(ecode2)) {
48625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48626 }
48627 arg2 = static_cast< int >(val2);
48628 {
48629 PyThreadState* __tstate = wxPyBeginAllowThreads();
48630 (arg1)->SetCol(arg2);
48631 wxPyEndAllowThreads(__tstate);
48632 if (PyErr_Occurred()) SWIG_fail;
48633 }
48634 resultobj = SWIG_Py_Void();
48635 return resultobj;
48636 fail:
48637 return NULL;
48638 }
48639
48640
48641 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48642 PyObject *resultobj = 0;
48643 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48644 wxGBPosition *arg2 = 0 ;
48645 bool result;
48646 void *argp1 = 0 ;
48647 int res1 = 0 ;
48648 wxGBPosition temp2 ;
48649 PyObject * obj0 = 0 ;
48650 PyObject * obj1 = 0 ;
48651 char * kwnames[] = {
48652 (char *) "self",(char *) "other", NULL
48653 };
48654
48655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48657 if (!SWIG_IsOK(res1)) {
48658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48659 }
48660 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48661 {
48662 arg2 = &temp2;
48663 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
48664 }
48665 {
48666 PyThreadState* __tstate = wxPyBeginAllowThreads();
48667 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
48668 wxPyEndAllowThreads(__tstate);
48669 if (PyErr_Occurred()) SWIG_fail;
48670 }
48671 {
48672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48673 }
48674 return resultobj;
48675 fail:
48676 return NULL;
48677 }
48678
48679
48680 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48681 PyObject *resultobj = 0;
48682 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48683 wxGBPosition *arg2 = 0 ;
48684 bool result;
48685 void *argp1 = 0 ;
48686 int res1 = 0 ;
48687 wxGBPosition temp2 ;
48688 PyObject * obj0 = 0 ;
48689 PyObject * obj1 = 0 ;
48690 char * kwnames[] = {
48691 (char *) "self",(char *) "other", NULL
48692 };
48693
48694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48696 if (!SWIG_IsOK(res1)) {
48697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48698 }
48699 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48700 {
48701 arg2 = &temp2;
48702 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
48703 }
48704 {
48705 PyThreadState* __tstate = wxPyBeginAllowThreads();
48706 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
48707 wxPyEndAllowThreads(__tstate);
48708 if (PyErr_Occurred()) SWIG_fail;
48709 }
48710 {
48711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48712 }
48713 return resultobj;
48714 fail:
48715 return NULL;
48716 }
48717
48718
48719 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48720 PyObject *resultobj = 0;
48721 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48722 int arg2 = (int) 0 ;
48723 int arg3 = (int) 0 ;
48724 void *argp1 = 0 ;
48725 int res1 = 0 ;
48726 int val2 ;
48727 int ecode2 = 0 ;
48728 int val3 ;
48729 int ecode3 = 0 ;
48730 PyObject * obj0 = 0 ;
48731 PyObject * obj1 = 0 ;
48732 PyObject * obj2 = 0 ;
48733 char * kwnames[] = {
48734 (char *) "self",(char *) "row",(char *) "col", NULL
48735 };
48736
48737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48739 if (!SWIG_IsOK(res1)) {
48740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48741 }
48742 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48743 if (obj1) {
48744 ecode2 = SWIG_AsVal_int(obj1, &val2);
48745 if (!SWIG_IsOK(ecode2)) {
48746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48747 }
48748 arg2 = static_cast< int >(val2);
48749 }
48750 if (obj2) {
48751 ecode3 = SWIG_AsVal_int(obj2, &val3);
48752 if (!SWIG_IsOK(ecode3)) {
48753 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
48754 }
48755 arg3 = static_cast< int >(val3);
48756 }
48757 {
48758 PyThreadState* __tstate = wxPyBeginAllowThreads();
48759 wxGBPosition_Set(arg1,arg2,arg3);
48760 wxPyEndAllowThreads(__tstate);
48761 if (PyErr_Occurred()) SWIG_fail;
48762 }
48763 resultobj = SWIG_Py_Void();
48764 return resultobj;
48765 fail:
48766 return NULL;
48767 }
48768
48769
48770 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48771 PyObject *resultobj = 0;
48772 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48773 PyObject *result = 0 ;
48774 void *argp1 = 0 ;
48775 int res1 = 0 ;
48776 PyObject *swig_obj[1] ;
48777
48778 if (!args) SWIG_fail;
48779 swig_obj[0] = args;
48780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48781 if (!SWIG_IsOK(res1)) {
48782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48783 }
48784 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48785 {
48786 PyThreadState* __tstate = wxPyBeginAllowThreads();
48787 result = (PyObject *)wxGBPosition_Get(arg1);
48788 wxPyEndAllowThreads(__tstate);
48789 if (PyErr_Occurred()) SWIG_fail;
48790 }
48791 resultobj = result;
48792 return resultobj;
48793 fail:
48794 return NULL;
48795 }
48796
48797
48798 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48799 PyObject *obj;
48800 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48801 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
48802 return SWIG_Py_Void();
48803 }
48804
48805 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48806 return SWIG_Python_InitShadowInstance(args);
48807 }
48808
48809 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48810 PyObject *resultobj = 0;
48811 int arg1 = (int) 1 ;
48812 int arg2 = (int) 1 ;
48813 wxGBSpan *result = 0 ;
48814 int val1 ;
48815 int ecode1 = 0 ;
48816 int val2 ;
48817 int ecode2 = 0 ;
48818 PyObject * obj0 = 0 ;
48819 PyObject * obj1 = 0 ;
48820 char * kwnames[] = {
48821 (char *) "rowspan",(char *) "colspan", NULL
48822 };
48823
48824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
48825 if (obj0) {
48826 ecode1 = SWIG_AsVal_int(obj0, &val1);
48827 if (!SWIG_IsOK(ecode1)) {
48828 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
48829 }
48830 arg1 = static_cast< int >(val1);
48831 }
48832 if (obj1) {
48833 ecode2 = SWIG_AsVal_int(obj1, &val2);
48834 if (!SWIG_IsOK(ecode2)) {
48835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
48836 }
48837 arg2 = static_cast< int >(val2);
48838 }
48839 {
48840 PyThreadState* __tstate = wxPyBeginAllowThreads();
48841 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
48842 wxPyEndAllowThreads(__tstate);
48843 if (PyErr_Occurred()) SWIG_fail;
48844 }
48845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
48846 return resultobj;
48847 fail:
48848 return NULL;
48849 }
48850
48851
48852 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48853 PyObject *resultobj = 0;
48854 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48855 void *argp1 = 0 ;
48856 int res1 = 0 ;
48857 PyObject *swig_obj[1] ;
48858
48859 if (!args) SWIG_fail;
48860 swig_obj[0] = args;
48861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
48862 if (!SWIG_IsOK(res1)) {
48863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48864 }
48865 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48866 {
48867 PyThreadState* __tstate = wxPyBeginAllowThreads();
48868 delete arg1;
48869
48870 wxPyEndAllowThreads(__tstate);
48871 if (PyErr_Occurred()) SWIG_fail;
48872 }
48873 resultobj = SWIG_Py_Void();
48874 return resultobj;
48875 fail:
48876 return NULL;
48877 }
48878
48879
48880 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48881 PyObject *resultobj = 0;
48882 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48883 int result;
48884 void *argp1 = 0 ;
48885 int res1 = 0 ;
48886 PyObject *swig_obj[1] ;
48887
48888 if (!args) SWIG_fail;
48889 swig_obj[0] = args;
48890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48891 if (!SWIG_IsOK(res1)) {
48892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48893 }
48894 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48895 {
48896 PyThreadState* __tstate = wxPyBeginAllowThreads();
48897 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
48898 wxPyEndAllowThreads(__tstate);
48899 if (PyErr_Occurred()) SWIG_fail;
48900 }
48901 resultobj = SWIG_From_int(static_cast< int >(result));
48902 return resultobj;
48903 fail:
48904 return NULL;
48905 }
48906
48907
48908 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48909 PyObject *resultobj = 0;
48910 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48911 int result;
48912 void *argp1 = 0 ;
48913 int res1 = 0 ;
48914 PyObject *swig_obj[1] ;
48915
48916 if (!args) SWIG_fail;
48917 swig_obj[0] = args;
48918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48919 if (!SWIG_IsOK(res1)) {
48920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48921 }
48922 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48923 {
48924 PyThreadState* __tstate = wxPyBeginAllowThreads();
48925 result = (int)((wxGBSpan const *)arg1)->GetColspan();
48926 wxPyEndAllowThreads(__tstate);
48927 if (PyErr_Occurred()) SWIG_fail;
48928 }
48929 resultobj = SWIG_From_int(static_cast< int >(result));
48930 return resultobj;
48931 fail:
48932 return NULL;
48933 }
48934
48935
48936 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48937 PyObject *resultobj = 0;
48938 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48939 int arg2 ;
48940 void *argp1 = 0 ;
48941 int res1 = 0 ;
48942 int val2 ;
48943 int ecode2 = 0 ;
48944 PyObject * obj0 = 0 ;
48945 PyObject * obj1 = 0 ;
48946 char * kwnames[] = {
48947 (char *) "self",(char *) "rowspan", NULL
48948 };
48949
48950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
48951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48952 if (!SWIG_IsOK(res1)) {
48953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48954 }
48955 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48956 ecode2 = SWIG_AsVal_int(obj1, &val2);
48957 if (!SWIG_IsOK(ecode2)) {
48958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
48959 }
48960 arg2 = static_cast< int >(val2);
48961 {
48962 PyThreadState* __tstate = wxPyBeginAllowThreads();
48963 (arg1)->SetRowspan(arg2);
48964 wxPyEndAllowThreads(__tstate);
48965 if (PyErr_Occurred()) SWIG_fail;
48966 }
48967 resultobj = SWIG_Py_Void();
48968 return resultobj;
48969 fail:
48970 return NULL;
48971 }
48972
48973
48974 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48975 PyObject *resultobj = 0;
48976 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48977 int arg2 ;
48978 void *argp1 = 0 ;
48979 int res1 = 0 ;
48980 int val2 ;
48981 int ecode2 = 0 ;
48982 PyObject * obj0 = 0 ;
48983 PyObject * obj1 = 0 ;
48984 char * kwnames[] = {
48985 (char *) "self",(char *) "colspan", NULL
48986 };
48987
48988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
48989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48990 if (!SWIG_IsOK(res1)) {
48991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48992 }
48993 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48994 ecode2 = SWIG_AsVal_int(obj1, &val2);
48995 if (!SWIG_IsOK(ecode2)) {
48996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
48997 }
48998 arg2 = static_cast< int >(val2);
48999 {
49000 PyThreadState* __tstate = wxPyBeginAllowThreads();
49001 (arg1)->SetColspan(arg2);
49002 wxPyEndAllowThreads(__tstate);
49003 if (PyErr_Occurred()) SWIG_fail;
49004 }
49005 resultobj = SWIG_Py_Void();
49006 return resultobj;
49007 fail:
49008 return NULL;
49009 }
49010
49011
49012 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49013 PyObject *resultobj = 0;
49014 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49015 wxGBSpan *arg2 = 0 ;
49016 bool result;
49017 void *argp1 = 0 ;
49018 int res1 = 0 ;
49019 wxGBSpan temp2 ;
49020 PyObject * obj0 = 0 ;
49021 PyObject * obj1 = 0 ;
49022 char * kwnames[] = {
49023 (char *) "self",(char *) "other", NULL
49024 };
49025
49026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49028 if (!SWIG_IsOK(res1)) {
49029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49030 }
49031 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49032 {
49033 arg2 = &temp2;
49034 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49035 }
49036 {
49037 PyThreadState* __tstate = wxPyBeginAllowThreads();
49038 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
49039 wxPyEndAllowThreads(__tstate);
49040 if (PyErr_Occurred()) SWIG_fail;
49041 }
49042 {
49043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49044 }
49045 return resultobj;
49046 fail:
49047 return NULL;
49048 }
49049
49050
49051 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49052 PyObject *resultobj = 0;
49053 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49054 wxGBSpan *arg2 = 0 ;
49055 bool result;
49056 void *argp1 = 0 ;
49057 int res1 = 0 ;
49058 wxGBSpan temp2 ;
49059 PyObject * obj0 = 0 ;
49060 PyObject * obj1 = 0 ;
49061 char * kwnames[] = {
49062 (char *) "self",(char *) "other", NULL
49063 };
49064
49065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49067 if (!SWIG_IsOK(res1)) {
49068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49069 }
49070 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49071 {
49072 arg2 = &temp2;
49073 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49074 }
49075 {
49076 PyThreadState* __tstate = wxPyBeginAllowThreads();
49077 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
49078 wxPyEndAllowThreads(__tstate);
49079 if (PyErr_Occurred()) SWIG_fail;
49080 }
49081 {
49082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49083 }
49084 return resultobj;
49085 fail:
49086 return NULL;
49087 }
49088
49089
49090 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49091 PyObject *resultobj = 0;
49092 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49093 int arg2 = (int) 1 ;
49094 int arg3 = (int) 1 ;
49095 void *argp1 = 0 ;
49096 int res1 = 0 ;
49097 int val2 ;
49098 int ecode2 = 0 ;
49099 int val3 ;
49100 int ecode3 = 0 ;
49101 PyObject * obj0 = 0 ;
49102 PyObject * obj1 = 0 ;
49103 PyObject * obj2 = 0 ;
49104 char * kwnames[] = {
49105 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49106 };
49107
49108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49110 if (!SWIG_IsOK(res1)) {
49111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49112 }
49113 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49114 if (obj1) {
49115 ecode2 = SWIG_AsVal_int(obj1, &val2);
49116 if (!SWIG_IsOK(ecode2)) {
49117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49118 }
49119 arg2 = static_cast< int >(val2);
49120 }
49121 if (obj2) {
49122 ecode3 = SWIG_AsVal_int(obj2, &val3);
49123 if (!SWIG_IsOK(ecode3)) {
49124 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49125 }
49126 arg3 = static_cast< int >(val3);
49127 }
49128 {
49129 PyThreadState* __tstate = wxPyBeginAllowThreads();
49130 wxGBSpan_Set(arg1,arg2,arg3);
49131 wxPyEndAllowThreads(__tstate);
49132 if (PyErr_Occurred()) SWIG_fail;
49133 }
49134 resultobj = SWIG_Py_Void();
49135 return resultobj;
49136 fail:
49137 return NULL;
49138 }
49139
49140
49141 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49142 PyObject *resultobj = 0;
49143 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49144 PyObject *result = 0 ;
49145 void *argp1 = 0 ;
49146 int res1 = 0 ;
49147 PyObject *swig_obj[1] ;
49148
49149 if (!args) SWIG_fail;
49150 swig_obj[0] = args;
49151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49152 if (!SWIG_IsOK(res1)) {
49153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49154 }
49155 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49156 {
49157 PyThreadState* __tstate = wxPyBeginAllowThreads();
49158 result = (PyObject *)wxGBSpan_Get(arg1);
49159 wxPyEndAllowThreads(__tstate);
49160 if (PyErr_Occurred()) SWIG_fail;
49161 }
49162 resultobj = result;
49163 return resultobj;
49164 fail:
49165 return NULL;
49166 }
49167
49168
49169 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49170 PyObject *obj;
49171 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49172 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49173 return SWIG_Py_Void();
49174 }
49175
49176 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49177 return SWIG_Python_InitShadowInstance(args);
49178 }
49179
49180 SWIGINTERN int DefaultSpan_set(PyObject *) {
49181 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49182 return 1;
49183 }
49184
49185
49186 SWIGINTERN PyObject *DefaultSpan_get(void) {
49187 PyObject *pyobj = 0;
49188
49189 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49190 return pyobj;
49191 }
49192
49193
49194 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49195 PyObject *resultobj = 0;
49196 wxGBSizerItem *result = 0 ;
49197
49198 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49199 {
49200 PyThreadState* __tstate = wxPyBeginAllowThreads();
49201 result = (wxGBSizerItem *)new wxGBSizerItem();
49202 wxPyEndAllowThreads(__tstate);
49203 if (PyErr_Occurred()) SWIG_fail;
49204 }
49205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49206 return resultobj;
49207 fail:
49208 return NULL;
49209 }
49210
49211
49212 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49213 PyObject *resultobj = 0;
49214 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49215 void *argp1 = 0 ;
49216 int res1 = 0 ;
49217 PyObject *swig_obj[1] ;
49218
49219 if (!args) SWIG_fail;
49220 swig_obj[0] = args;
49221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49222 if (!SWIG_IsOK(res1)) {
49223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49224 }
49225 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49226 {
49227 PyThreadState* __tstate = wxPyBeginAllowThreads();
49228 delete arg1;
49229
49230 wxPyEndAllowThreads(__tstate);
49231 if (PyErr_Occurred()) SWIG_fail;
49232 }
49233 resultobj = SWIG_Py_Void();
49234 return resultobj;
49235 fail:
49236 return NULL;
49237 }
49238
49239
49240 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49241 PyObject *resultobj = 0;
49242 wxWindow *arg1 = (wxWindow *) 0 ;
49243 wxGBPosition *arg2 = 0 ;
49244 wxGBSpan *arg3 = 0 ;
49245 int arg4 ;
49246 int arg5 ;
49247 PyObject *arg6 = (PyObject *) NULL ;
49248 wxGBSizerItem *result = 0 ;
49249 void *argp1 = 0 ;
49250 int res1 = 0 ;
49251 wxGBPosition temp2 ;
49252 wxGBSpan temp3 ;
49253 int val4 ;
49254 int ecode4 = 0 ;
49255 int val5 ;
49256 int ecode5 = 0 ;
49257 PyObject * obj0 = 0 ;
49258 PyObject * obj1 = 0 ;
49259 PyObject * obj2 = 0 ;
49260 PyObject * obj3 = 0 ;
49261 PyObject * obj4 = 0 ;
49262 PyObject * obj5 = 0 ;
49263 char * kwnames[] = {
49264 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49265 };
49266
49267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49269 if (!SWIG_IsOK(res1)) {
49270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49271 }
49272 arg1 = reinterpret_cast< wxWindow * >(argp1);
49273 {
49274 arg2 = &temp2;
49275 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49276 }
49277 {
49278 arg3 = &temp3;
49279 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49280 }
49281 ecode4 = SWIG_AsVal_int(obj3, &val4);
49282 if (!SWIG_IsOK(ecode4)) {
49283 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49284 }
49285 arg4 = static_cast< int >(val4);
49286 ecode5 = SWIG_AsVal_int(obj4, &val5);
49287 if (!SWIG_IsOK(ecode5)) {
49288 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49289 }
49290 arg5 = static_cast< int >(val5);
49291 if (obj5) {
49292 arg6 = obj5;
49293 }
49294 {
49295 PyThreadState* __tstate = wxPyBeginAllowThreads();
49296 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49297 wxPyEndAllowThreads(__tstate);
49298 if (PyErr_Occurred()) SWIG_fail;
49299 }
49300 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49301 return resultobj;
49302 fail:
49303 return NULL;
49304 }
49305
49306
49307 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49308 PyObject *resultobj = 0;
49309 wxSizer *arg1 = (wxSizer *) 0 ;
49310 wxGBPosition *arg2 = 0 ;
49311 wxGBSpan *arg3 = 0 ;
49312 int arg4 ;
49313 int arg5 ;
49314 PyObject *arg6 = (PyObject *) NULL ;
49315 wxGBSizerItem *result = 0 ;
49316 int res1 = 0 ;
49317 wxGBPosition temp2 ;
49318 wxGBSpan temp3 ;
49319 int val4 ;
49320 int ecode4 = 0 ;
49321 int val5 ;
49322 int ecode5 = 0 ;
49323 PyObject * obj0 = 0 ;
49324 PyObject * obj1 = 0 ;
49325 PyObject * obj2 = 0 ;
49326 PyObject * obj3 = 0 ;
49327 PyObject * obj4 = 0 ;
49328 PyObject * obj5 = 0 ;
49329 char * kwnames[] = {
49330 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49331 };
49332
49333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49334 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49335 if (!SWIG_IsOK(res1)) {
49336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49337 }
49338 {
49339 arg2 = &temp2;
49340 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49341 }
49342 {
49343 arg3 = &temp3;
49344 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49345 }
49346 ecode4 = SWIG_AsVal_int(obj3, &val4);
49347 if (!SWIG_IsOK(ecode4)) {
49348 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49349 }
49350 arg4 = static_cast< int >(val4);
49351 ecode5 = SWIG_AsVal_int(obj4, &val5);
49352 if (!SWIG_IsOK(ecode5)) {
49353 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49354 }
49355 arg5 = static_cast< int >(val5);
49356 if (obj5) {
49357 arg6 = obj5;
49358 }
49359 {
49360 PyThreadState* __tstate = wxPyBeginAllowThreads();
49361 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49362 wxPyEndAllowThreads(__tstate);
49363 if (PyErr_Occurred()) SWIG_fail;
49364 }
49365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49366 return resultobj;
49367 fail:
49368 return NULL;
49369 }
49370
49371
49372 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49373 PyObject *resultobj = 0;
49374 int arg1 ;
49375 int arg2 ;
49376 wxGBPosition *arg3 = 0 ;
49377 wxGBSpan *arg4 = 0 ;
49378 int arg5 ;
49379 int arg6 ;
49380 PyObject *arg7 = (PyObject *) NULL ;
49381 wxGBSizerItem *result = 0 ;
49382 int val1 ;
49383 int ecode1 = 0 ;
49384 int val2 ;
49385 int ecode2 = 0 ;
49386 wxGBPosition temp3 ;
49387 wxGBSpan temp4 ;
49388 int val5 ;
49389 int ecode5 = 0 ;
49390 int val6 ;
49391 int ecode6 = 0 ;
49392 PyObject * obj0 = 0 ;
49393 PyObject * obj1 = 0 ;
49394 PyObject * obj2 = 0 ;
49395 PyObject * obj3 = 0 ;
49396 PyObject * obj4 = 0 ;
49397 PyObject * obj5 = 0 ;
49398 PyObject * obj6 = 0 ;
49399 char * kwnames[] = {
49400 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49401 };
49402
49403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49404 ecode1 = SWIG_AsVal_int(obj0, &val1);
49405 if (!SWIG_IsOK(ecode1)) {
49406 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49407 }
49408 arg1 = static_cast< int >(val1);
49409 ecode2 = SWIG_AsVal_int(obj1, &val2);
49410 if (!SWIG_IsOK(ecode2)) {
49411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49412 }
49413 arg2 = static_cast< int >(val2);
49414 {
49415 arg3 = &temp3;
49416 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49417 }
49418 {
49419 arg4 = &temp4;
49420 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49421 }
49422 ecode5 = SWIG_AsVal_int(obj4, &val5);
49423 if (!SWIG_IsOK(ecode5)) {
49424 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49425 }
49426 arg5 = static_cast< int >(val5);
49427 ecode6 = SWIG_AsVal_int(obj5, &val6);
49428 if (!SWIG_IsOK(ecode6)) {
49429 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49430 }
49431 arg6 = static_cast< int >(val6);
49432 if (obj6) {
49433 arg7 = obj6;
49434 }
49435 {
49436 PyThreadState* __tstate = wxPyBeginAllowThreads();
49437 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49438 wxPyEndAllowThreads(__tstate);
49439 if (PyErr_Occurred()) SWIG_fail;
49440 }
49441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49442 return resultobj;
49443 fail:
49444 return NULL;
49445 }
49446
49447
49448 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49449 PyObject *resultobj = 0;
49450 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49451 wxGBPosition result;
49452 void *argp1 = 0 ;
49453 int res1 = 0 ;
49454 PyObject *swig_obj[1] ;
49455
49456 if (!args) SWIG_fail;
49457 swig_obj[0] = args;
49458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49459 if (!SWIG_IsOK(res1)) {
49460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49461 }
49462 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49463 {
49464 PyThreadState* __tstate = wxPyBeginAllowThreads();
49465 result = ((wxGBSizerItem const *)arg1)->GetPos();
49466 wxPyEndAllowThreads(__tstate);
49467 if (PyErr_Occurred()) SWIG_fail;
49468 }
49469 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49470 return resultobj;
49471 fail:
49472 return NULL;
49473 }
49474
49475
49476 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49477 PyObject *resultobj = 0;
49478 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49479 wxGBSpan result;
49480 void *argp1 = 0 ;
49481 int res1 = 0 ;
49482 PyObject *swig_obj[1] ;
49483
49484 if (!args) SWIG_fail;
49485 swig_obj[0] = args;
49486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49487 if (!SWIG_IsOK(res1)) {
49488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49489 }
49490 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49491 {
49492 PyThreadState* __tstate = wxPyBeginAllowThreads();
49493 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49494 wxPyEndAllowThreads(__tstate);
49495 if (PyErr_Occurred()) SWIG_fail;
49496 }
49497 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49498 return resultobj;
49499 fail:
49500 return NULL;
49501 }
49502
49503
49504 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49505 PyObject *resultobj = 0;
49506 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49507 wxGBPosition *arg2 = 0 ;
49508 bool result;
49509 void *argp1 = 0 ;
49510 int res1 = 0 ;
49511 wxGBPosition temp2 ;
49512 PyObject * obj0 = 0 ;
49513 PyObject * obj1 = 0 ;
49514 char * kwnames[] = {
49515 (char *) "self",(char *) "pos", NULL
49516 };
49517
49518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49520 if (!SWIG_IsOK(res1)) {
49521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49522 }
49523 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49524 {
49525 arg2 = &temp2;
49526 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49527 }
49528 {
49529 PyThreadState* __tstate = wxPyBeginAllowThreads();
49530 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49531 wxPyEndAllowThreads(__tstate);
49532 if (PyErr_Occurred()) SWIG_fail;
49533 }
49534 {
49535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49536 }
49537 return resultobj;
49538 fail:
49539 return NULL;
49540 }
49541
49542
49543 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49544 PyObject *resultobj = 0;
49545 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49546 wxGBSpan *arg2 = 0 ;
49547 bool result;
49548 void *argp1 = 0 ;
49549 int res1 = 0 ;
49550 wxGBSpan temp2 ;
49551 PyObject * obj0 = 0 ;
49552 PyObject * obj1 = 0 ;
49553 char * kwnames[] = {
49554 (char *) "self",(char *) "span", NULL
49555 };
49556
49557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49559 if (!SWIG_IsOK(res1)) {
49560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49561 }
49562 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49563 {
49564 arg2 = &temp2;
49565 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49566 }
49567 {
49568 PyThreadState* __tstate = wxPyBeginAllowThreads();
49569 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49570 wxPyEndAllowThreads(__tstate);
49571 if (PyErr_Occurred()) SWIG_fail;
49572 }
49573 {
49574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49575 }
49576 return resultobj;
49577 fail:
49578 return NULL;
49579 }
49580
49581
49582 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49583 PyObject *resultobj = 0;
49584 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49585 wxGBSizerItem *arg2 = 0 ;
49586 bool result;
49587 void *argp1 = 0 ;
49588 int res1 = 0 ;
49589 void *argp2 = 0 ;
49590 int res2 = 0 ;
49591 PyObject * obj0 = 0 ;
49592 PyObject * obj1 = 0 ;
49593 char * kwnames[] = {
49594 (char *) "self",(char *) "other", NULL
49595 };
49596
49597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49599 if (!SWIG_IsOK(res1)) {
49600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49601 }
49602 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49603 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49604 if (!SWIG_IsOK(res2)) {
49605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49606 }
49607 if (!argp2) {
49608 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49609 }
49610 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49611 {
49612 PyThreadState* __tstate = wxPyBeginAllowThreads();
49613 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49614 wxPyEndAllowThreads(__tstate);
49615 if (PyErr_Occurred()) SWIG_fail;
49616 }
49617 {
49618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49619 }
49620 return resultobj;
49621 fail:
49622 return NULL;
49623 }
49624
49625
49626 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49627 PyObject *resultobj = 0;
49628 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49629 wxGBPosition *arg2 = 0 ;
49630 wxGBSpan *arg3 = 0 ;
49631 bool result;
49632 void *argp1 = 0 ;
49633 int res1 = 0 ;
49634 wxGBPosition temp2 ;
49635 wxGBSpan temp3 ;
49636 PyObject * obj0 = 0 ;
49637 PyObject * obj1 = 0 ;
49638 PyObject * obj2 = 0 ;
49639 char * kwnames[] = {
49640 (char *) "self",(char *) "pos",(char *) "span", NULL
49641 };
49642
49643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49645 if (!SWIG_IsOK(res1)) {
49646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49647 }
49648 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49649 {
49650 arg2 = &temp2;
49651 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49652 }
49653 {
49654 arg3 = &temp3;
49655 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49656 }
49657 {
49658 PyThreadState* __tstate = wxPyBeginAllowThreads();
49659 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49660 wxPyEndAllowThreads(__tstate);
49661 if (PyErr_Occurred()) SWIG_fail;
49662 }
49663 {
49664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49665 }
49666 return resultobj;
49667 fail:
49668 return NULL;
49669 }
49670
49671
49672 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49673 PyObject *resultobj = 0;
49674 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49675 wxGBPosition result;
49676 void *argp1 = 0 ;
49677 int res1 = 0 ;
49678 PyObject *swig_obj[1] ;
49679
49680 if (!args) SWIG_fail;
49681 swig_obj[0] = args;
49682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49683 if (!SWIG_IsOK(res1)) {
49684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49685 }
49686 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49687 {
49688 PyThreadState* __tstate = wxPyBeginAllowThreads();
49689 result = wxGBSizerItem_GetEndPos(arg1);
49690 wxPyEndAllowThreads(__tstate);
49691 if (PyErr_Occurred()) SWIG_fail;
49692 }
49693 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49694 return resultobj;
49695 fail:
49696 return NULL;
49697 }
49698
49699
49700 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49701 PyObject *resultobj = 0;
49702 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49703 wxGridBagSizer *result = 0 ;
49704 void *argp1 = 0 ;
49705 int res1 = 0 ;
49706 PyObject *swig_obj[1] ;
49707
49708 if (!args) SWIG_fail;
49709 swig_obj[0] = args;
49710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49711 if (!SWIG_IsOK(res1)) {
49712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49713 }
49714 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49715 {
49716 PyThreadState* __tstate = wxPyBeginAllowThreads();
49717 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49718 wxPyEndAllowThreads(__tstate);
49719 if (PyErr_Occurred()) SWIG_fail;
49720 }
49721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49722 return resultobj;
49723 fail:
49724 return NULL;
49725 }
49726
49727
49728 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49729 PyObject *resultobj = 0;
49730 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49731 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49732 void *argp1 = 0 ;
49733 int res1 = 0 ;
49734 void *argp2 = 0 ;
49735 int res2 = 0 ;
49736 PyObject * obj0 = 0 ;
49737 PyObject * obj1 = 0 ;
49738 char * kwnames[] = {
49739 (char *) "self",(char *) "sizer", NULL
49740 };
49741
49742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49744 if (!SWIG_IsOK(res1)) {
49745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49746 }
49747 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49748 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49749 if (!SWIG_IsOK(res2)) {
49750 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49751 }
49752 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49753 {
49754 PyThreadState* __tstate = wxPyBeginAllowThreads();
49755 (arg1)->SetGBSizer(arg2);
49756 wxPyEndAllowThreads(__tstate);
49757 if (PyErr_Occurred()) SWIG_fail;
49758 }
49759 resultobj = SWIG_Py_Void();
49760 return resultobj;
49761 fail:
49762 return NULL;
49763 }
49764
49765
49766 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49767 PyObject *obj;
49768 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49769 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
49770 return SWIG_Py_Void();
49771 }
49772
49773 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49774 return SWIG_Python_InitShadowInstance(args);
49775 }
49776
49777 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49778 PyObject *resultobj = 0;
49779 int arg1 = (int) 0 ;
49780 int arg2 = (int) 0 ;
49781 wxGridBagSizer *result = 0 ;
49782 int val1 ;
49783 int ecode1 = 0 ;
49784 int val2 ;
49785 int ecode2 = 0 ;
49786 PyObject * obj0 = 0 ;
49787 PyObject * obj1 = 0 ;
49788 char * kwnames[] = {
49789 (char *) "vgap",(char *) "hgap", NULL
49790 };
49791
49792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49793 if (obj0) {
49794 ecode1 = SWIG_AsVal_int(obj0, &val1);
49795 if (!SWIG_IsOK(ecode1)) {
49796 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
49797 }
49798 arg1 = static_cast< int >(val1);
49799 }
49800 if (obj1) {
49801 ecode2 = SWIG_AsVal_int(obj1, &val2);
49802 if (!SWIG_IsOK(ecode2)) {
49803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
49804 }
49805 arg2 = static_cast< int >(val2);
49806 }
49807 {
49808 PyThreadState* __tstate = wxPyBeginAllowThreads();
49809 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
49810 wxPyEndAllowThreads(__tstate);
49811 if (PyErr_Occurred()) SWIG_fail;
49812 }
49813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
49814 return resultobj;
49815 fail:
49816 return NULL;
49817 }
49818
49819
49820 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49821 PyObject *resultobj = 0;
49822 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49823 PyObject *arg2 = (PyObject *) 0 ;
49824 wxGBPosition *arg3 = 0 ;
49825 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
49826 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
49827 int arg5 = (int) 0 ;
49828 int arg6 = (int) 0 ;
49829 PyObject *arg7 = (PyObject *) NULL ;
49830 wxGBSizerItem *result = 0 ;
49831 void *argp1 = 0 ;
49832 int res1 = 0 ;
49833 wxGBPosition temp3 ;
49834 wxGBSpan temp4 ;
49835 int val5 ;
49836 int ecode5 = 0 ;
49837 int val6 ;
49838 int ecode6 = 0 ;
49839 PyObject * obj0 = 0 ;
49840 PyObject * obj1 = 0 ;
49841 PyObject * obj2 = 0 ;
49842 PyObject * obj3 = 0 ;
49843 PyObject * obj4 = 0 ;
49844 PyObject * obj5 = 0 ;
49845 PyObject * obj6 = 0 ;
49846 char * kwnames[] = {
49847 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49848 };
49849
49850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49852 if (!SWIG_IsOK(res1)) {
49853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49854 }
49855 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49856 arg2 = obj1;
49857 {
49858 arg3 = &temp3;
49859 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49860 }
49861 if (obj3) {
49862 {
49863 arg4 = &temp4;
49864 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49865 }
49866 }
49867 if (obj4) {
49868 ecode5 = SWIG_AsVal_int(obj4, &val5);
49869 if (!SWIG_IsOK(ecode5)) {
49870 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
49871 }
49872 arg5 = static_cast< int >(val5);
49873 }
49874 if (obj5) {
49875 ecode6 = SWIG_AsVal_int(obj5, &val6);
49876 if (!SWIG_IsOK(ecode6)) {
49877 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
49878 }
49879 arg6 = static_cast< int >(val6);
49880 }
49881 if (obj6) {
49882 arg7 = obj6;
49883 }
49884 {
49885 PyThreadState* __tstate = wxPyBeginAllowThreads();
49886 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49887 wxPyEndAllowThreads(__tstate);
49888 if (PyErr_Occurred()) SWIG_fail;
49889 }
49890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49891 return resultobj;
49892 fail:
49893 return NULL;
49894 }
49895
49896
49897 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49898 PyObject *resultobj = 0;
49899 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49900 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
49901 wxGBSizerItem *result = 0 ;
49902 void *argp1 = 0 ;
49903 int res1 = 0 ;
49904 int res2 = 0 ;
49905 PyObject * obj0 = 0 ;
49906 PyObject * obj1 = 0 ;
49907 char * kwnames[] = {
49908 (char *) "self",(char *) "item", NULL
49909 };
49910
49911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
49912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49913 if (!SWIG_IsOK(res1)) {
49914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49915 }
49916 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49917 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49918 if (!SWIG_IsOK(res2)) {
49919 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
49920 }
49921 {
49922 PyThreadState* __tstate = wxPyBeginAllowThreads();
49923 result = (wxGBSizerItem *)(arg1)->Add(arg2);
49924 wxPyEndAllowThreads(__tstate);
49925 if (PyErr_Occurred()) SWIG_fail;
49926 }
49927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49928 return resultobj;
49929 fail:
49930 return NULL;
49931 }
49932
49933
49934 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49935 PyObject *resultobj = 0;
49936 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49937 int arg2 ;
49938 int arg3 ;
49939 wxSize result;
49940 void *argp1 = 0 ;
49941 int res1 = 0 ;
49942 int val2 ;
49943 int ecode2 = 0 ;
49944 int val3 ;
49945 int ecode3 = 0 ;
49946 PyObject * obj0 = 0 ;
49947 PyObject * obj1 = 0 ;
49948 PyObject * obj2 = 0 ;
49949 char * kwnames[] = {
49950 (char *) "self",(char *) "row",(char *) "col", NULL
49951 };
49952
49953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49955 if (!SWIG_IsOK(res1)) {
49956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
49957 }
49958 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49959 ecode2 = SWIG_AsVal_int(obj1, &val2);
49960 if (!SWIG_IsOK(ecode2)) {
49961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
49962 }
49963 arg2 = static_cast< int >(val2);
49964 ecode3 = SWIG_AsVal_int(obj2, &val3);
49965 if (!SWIG_IsOK(ecode3)) {
49966 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
49967 }
49968 arg3 = static_cast< int >(val3);
49969 {
49970 PyThreadState* __tstate = wxPyBeginAllowThreads();
49971 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
49972 wxPyEndAllowThreads(__tstate);
49973 if (PyErr_Occurred()) SWIG_fail;
49974 }
49975 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49976 return resultobj;
49977 fail:
49978 return NULL;
49979 }
49980
49981
49982 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49983 PyObject *resultobj = 0;
49984 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49985 wxSize result;
49986 void *argp1 = 0 ;
49987 int res1 = 0 ;
49988 PyObject *swig_obj[1] ;
49989
49990 if (!args) SWIG_fail;
49991 swig_obj[0] = args;
49992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49993 if (!SWIG_IsOK(res1)) {
49994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
49995 }
49996 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49997 {
49998 PyThreadState* __tstate = wxPyBeginAllowThreads();
49999 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50000 wxPyEndAllowThreads(__tstate);
50001 if (PyErr_Occurred()) SWIG_fail;
50002 }
50003 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50004 return resultobj;
50005 fail:
50006 return NULL;
50007 }
50008
50009
50010 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50011 PyObject *resultobj = 0;
50012 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50013 wxSize *arg2 = 0 ;
50014 void *argp1 = 0 ;
50015 int res1 = 0 ;
50016 wxSize temp2 ;
50017 PyObject * obj0 = 0 ;
50018 PyObject * obj1 = 0 ;
50019 char * kwnames[] = {
50020 (char *) "self",(char *) "sz", NULL
50021 };
50022
50023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50025 if (!SWIG_IsOK(res1)) {
50026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50027 }
50028 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50029 {
50030 arg2 = &temp2;
50031 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50032 }
50033 {
50034 PyThreadState* __tstate = wxPyBeginAllowThreads();
50035 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50036 wxPyEndAllowThreads(__tstate);
50037 if (PyErr_Occurred()) SWIG_fail;
50038 }
50039 resultobj = SWIG_Py_Void();
50040 return resultobj;
50041 fail:
50042 return NULL;
50043 }
50044
50045
50046 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50047 PyObject *resultobj = 0;
50048 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50049 wxWindow *arg2 = (wxWindow *) 0 ;
50050 wxGBPosition result;
50051 void *argp1 = 0 ;
50052 int res1 = 0 ;
50053 void *argp2 = 0 ;
50054 int res2 = 0 ;
50055
50056 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50058 if (!SWIG_IsOK(res1)) {
50059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50060 }
50061 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50062 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50063 if (!SWIG_IsOK(res2)) {
50064 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50065 }
50066 arg2 = reinterpret_cast< wxWindow * >(argp2);
50067 {
50068 PyThreadState* __tstate = wxPyBeginAllowThreads();
50069 result = (arg1)->GetItemPosition(arg2);
50070 wxPyEndAllowThreads(__tstate);
50071 if (PyErr_Occurred()) SWIG_fail;
50072 }
50073 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50074 return resultobj;
50075 fail:
50076 return NULL;
50077 }
50078
50079
50080 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50081 PyObject *resultobj = 0;
50082 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50083 wxSizer *arg2 = (wxSizer *) 0 ;
50084 wxGBPosition result;
50085 void *argp1 = 0 ;
50086 int res1 = 0 ;
50087 void *argp2 = 0 ;
50088 int res2 = 0 ;
50089
50090 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50092 if (!SWIG_IsOK(res1)) {
50093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50094 }
50095 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50096 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50097 if (!SWIG_IsOK(res2)) {
50098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50099 }
50100 arg2 = reinterpret_cast< wxSizer * >(argp2);
50101 {
50102 PyThreadState* __tstate = wxPyBeginAllowThreads();
50103 result = (arg1)->GetItemPosition(arg2);
50104 wxPyEndAllowThreads(__tstate);
50105 if (PyErr_Occurred()) SWIG_fail;
50106 }
50107 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50108 return resultobj;
50109 fail:
50110 return NULL;
50111 }
50112
50113
50114 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50115 PyObject *resultobj = 0;
50116 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50117 size_t arg2 ;
50118 wxGBPosition result;
50119 void *argp1 = 0 ;
50120 int res1 = 0 ;
50121 size_t val2 ;
50122 int ecode2 = 0 ;
50123
50124 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50126 if (!SWIG_IsOK(res1)) {
50127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50128 }
50129 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50130 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50131 if (!SWIG_IsOK(ecode2)) {
50132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50133 }
50134 arg2 = static_cast< size_t >(val2);
50135 {
50136 PyThreadState* __tstate = wxPyBeginAllowThreads();
50137 result = (arg1)->GetItemPosition(arg2);
50138 wxPyEndAllowThreads(__tstate);
50139 if (PyErr_Occurred()) SWIG_fail;
50140 }
50141 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50142 return resultobj;
50143 fail:
50144 return NULL;
50145 }
50146
50147
50148 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50149 int argc;
50150 PyObject *argv[3];
50151
50152 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50153 --argc;
50154 if (argc == 2) {
50155 int _v = 0;
50156 {
50157 void *vptr = 0;
50158 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50159 _v = SWIG_CheckState(res);
50160 }
50161 if (!_v) goto check_1;
50162 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50163 }
50164 check_1:
50165
50166 if (argc == 2) {
50167 int _v = 0;
50168 {
50169 void *vptr = 0;
50170 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50171 _v = SWIG_CheckState(res);
50172 }
50173 if (!_v) goto check_2;
50174 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50175 }
50176 check_2:
50177
50178 if (argc == 2) {
50179 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50180 }
50181
50182 fail:
50183 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50184 return NULL;
50185 }
50186
50187
50188 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50189 PyObject *resultobj = 0;
50190 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50191 wxWindow *arg2 = (wxWindow *) 0 ;
50192 wxGBPosition *arg3 = 0 ;
50193 bool result;
50194 void *argp1 = 0 ;
50195 int res1 = 0 ;
50196 void *argp2 = 0 ;
50197 int res2 = 0 ;
50198 wxGBPosition temp3 ;
50199
50200 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50202 if (!SWIG_IsOK(res1)) {
50203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50204 }
50205 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50206 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50207 if (!SWIG_IsOK(res2)) {
50208 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50209 }
50210 arg2 = reinterpret_cast< wxWindow * >(argp2);
50211 {
50212 arg3 = &temp3;
50213 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50214 }
50215 {
50216 PyThreadState* __tstate = wxPyBeginAllowThreads();
50217 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50218 wxPyEndAllowThreads(__tstate);
50219 if (PyErr_Occurred()) SWIG_fail;
50220 }
50221 {
50222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50223 }
50224 return resultobj;
50225 fail:
50226 return NULL;
50227 }
50228
50229
50230 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50231 PyObject *resultobj = 0;
50232 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50233 wxSizer *arg2 = (wxSizer *) 0 ;
50234 wxGBPosition *arg3 = 0 ;
50235 bool result;
50236 void *argp1 = 0 ;
50237 int res1 = 0 ;
50238 void *argp2 = 0 ;
50239 int res2 = 0 ;
50240 wxGBPosition temp3 ;
50241
50242 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50244 if (!SWIG_IsOK(res1)) {
50245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50246 }
50247 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50248 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50249 if (!SWIG_IsOK(res2)) {
50250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50251 }
50252 arg2 = reinterpret_cast< wxSizer * >(argp2);
50253 {
50254 arg3 = &temp3;
50255 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50256 }
50257 {
50258 PyThreadState* __tstate = wxPyBeginAllowThreads();
50259 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50260 wxPyEndAllowThreads(__tstate);
50261 if (PyErr_Occurred()) SWIG_fail;
50262 }
50263 {
50264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50265 }
50266 return resultobj;
50267 fail:
50268 return NULL;
50269 }
50270
50271
50272 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50273 PyObject *resultobj = 0;
50274 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50275 size_t arg2 ;
50276 wxGBPosition *arg3 = 0 ;
50277 bool result;
50278 void *argp1 = 0 ;
50279 int res1 = 0 ;
50280 size_t val2 ;
50281 int ecode2 = 0 ;
50282 wxGBPosition temp3 ;
50283
50284 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50286 if (!SWIG_IsOK(res1)) {
50287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50288 }
50289 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50290 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50291 if (!SWIG_IsOK(ecode2)) {
50292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50293 }
50294 arg2 = static_cast< size_t >(val2);
50295 {
50296 arg3 = &temp3;
50297 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50298 }
50299 {
50300 PyThreadState* __tstate = wxPyBeginAllowThreads();
50301 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50302 wxPyEndAllowThreads(__tstate);
50303 if (PyErr_Occurred()) SWIG_fail;
50304 }
50305 {
50306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50307 }
50308 return resultobj;
50309 fail:
50310 return NULL;
50311 }
50312
50313
50314 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50315 int argc;
50316 PyObject *argv[4];
50317
50318 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50319 --argc;
50320 if (argc == 3) {
50321 int _v = 0;
50322 {
50323 void *vptr = 0;
50324 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50325 _v = SWIG_CheckState(res);
50326 }
50327 if (!_v) goto check_1;
50328 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50329 }
50330 check_1:
50331
50332 if (argc == 3) {
50333 int _v = 0;
50334 {
50335 void *vptr = 0;
50336 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50337 _v = SWIG_CheckState(res);
50338 }
50339 if (!_v) goto check_2;
50340 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50341 }
50342 check_2:
50343
50344 if (argc == 3) {
50345 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50346 }
50347
50348 fail:
50349 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50350 return NULL;
50351 }
50352
50353
50354 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50355 PyObject *resultobj = 0;
50356 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50357 wxWindow *arg2 = (wxWindow *) 0 ;
50358 wxGBSpan result;
50359 void *argp1 = 0 ;
50360 int res1 = 0 ;
50361 void *argp2 = 0 ;
50362 int res2 = 0 ;
50363
50364 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50366 if (!SWIG_IsOK(res1)) {
50367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50368 }
50369 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50370 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50371 if (!SWIG_IsOK(res2)) {
50372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50373 }
50374 arg2 = reinterpret_cast< wxWindow * >(argp2);
50375 {
50376 PyThreadState* __tstate = wxPyBeginAllowThreads();
50377 result = (arg1)->GetItemSpan(arg2);
50378 wxPyEndAllowThreads(__tstate);
50379 if (PyErr_Occurred()) SWIG_fail;
50380 }
50381 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50382 return resultobj;
50383 fail:
50384 return NULL;
50385 }
50386
50387
50388 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50389 PyObject *resultobj = 0;
50390 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50391 wxSizer *arg2 = (wxSizer *) 0 ;
50392 wxGBSpan result;
50393 void *argp1 = 0 ;
50394 int res1 = 0 ;
50395 void *argp2 = 0 ;
50396 int res2 = 0 ;
50397
50398 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50400 if (!SWIG_IsOK(res1)) {
50401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50402 }
50403 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50404 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50405 if (!SWIG_IsOK(res2)) {
50406 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50407 }
50408 arg2 = reinterpret_cast< wxSizer * >(argp2);
50409 {
50410 PyThreadState* __tstate = wxPyBeginAllowThreads();
50411 result = (arg1)->GetItemSpan(arg2);
50412 wxPyEndAllowThreads(__tstate);
50413 if (PyErr_Occurred()) SWIG_fail;
50414 }
50415 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50416 return resultobj;
50417 fail:
50418 return NULL;
50419 }
50420
50421
50422 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50423 PyObject *resultobj = 0;
50424 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50425 size_t arg2 ;
50426 wxGBSpan result;
50427 void *argp1 = 0 ;
50428 int res1 = 0 ;
50429 size_t val2 ;
50430 int ecode2 = 0 ;
50431
50432 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50434 if (!SWIG_IsOK(res1)) {
50435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50436 }
50437 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50438 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50439 if (!SWIG_IsOK(ecode2)) {
50440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50441 }
50442 arg2 = static_cast< size_t >(val2);
50443 {
50444 PyThreadState* __tstate = wxPyBeginAllowThreads();
50445 result = (arg1)->GetItemSpan(arg2);
50446 wxPyEndAllowThreads(__tstate);
50447 if (PyErr_Occurred()) SWIG_fail;
50448 }
50449 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50450 return resultobj;
50451 fail:
50452 return NULL;
50453 }
50454
50455
50456 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50457 int argc;
50458 PyObject *argv[3];
50459
50460 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50461 --argc;
50462 if (argc == 2) {
50463 int _v = 0;
50464 {
50465 void *vptr = 0;
50466 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50467 _v = SWIG_CheckState(res);
50468 }
50469 if (!_v) goto check_1;
50470 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50471 }
50472 check_1:
50473
50474 if (argc == 2) {
50475 int _v = 0;
50476 {
50477 void *vptr = 0;
50478 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50479 _v = SWIG_CheckState(res);
50480 }
50481 if (!_v) goto check_2;
50482 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50483 }
50484 check_2:
50485
50486 if (argc == 2) {
50487 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50488 }
50489
50490 fail:
50491 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50492 return NULL;
50493 }
50494
50495
50496 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50497 PyObject *resultobj = 0;
50498 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50499 wxWindow *arg2 = (wxWindow *) 0 ;
50500 wxGBSpan *arg3 = 0 ;
50501 bool result;
50502 void *argp1 = 0 ;
50503 int res1 = 0 ;
50504 void *argp2 = 0 ;
50505 int res2 = 0 ;
50506 wxGBSpan temp3 ;
50507
50508 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50510 if (!SWIG_IsOK(res1)) {
50511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50512 }
50513 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50514 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50515 if (!SWIG_IsOK(res2)) {
50516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50517 }
50518 arg2 = reinterpret_cast< wxWindow * >(argp2);
50519 {
50520 arg3 = &temp3;
50521 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50522 }
50523 {
50524 PyThreadState* __tstate = wxPyBeginAllowThreads();
50525 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50526 wxPyEndAllowThreads(__tstate);
50527 if (PyErr_Occurred()) SWIG_fail;
50528 }
50529 {
50530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50531 }
50532 return resultobj;
50533 fail:
50534 return NULL;
50535 }
50536
50537
50538 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50539 PyObject *resultobj = 0;
50540 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50541 wxSizer *arg2 = (wxSizer *) 0 ;
50542 wxGBSpan *arg3 = 0 ;
50543 bool result;
50544 void *argp1 = 0 ;
50545 int res1 = 0 ;
50546 void *argp2 = 0 ;
50547 int res2 = 0 ;
50548 wxGBSpan temp3 ;
50549
50550 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50552 if (!SWIG_IsOK(res1)) {
50553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50554 }
50555 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50556 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50557 if (!SWIG_IsOK(res2)) {
50558 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50559 }
50560 arg2 = reinterpret_cast< wxSizer * >(argp2);
50561 {
50562 arg3 = &temp3;
50563 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50564 }
50565 {
50566 PyThreadState* __tstate = wxPyBeginAllowThreads();
50567 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50568 wxPyEndAllowThreads(__tstate);
50569 if (PyErr_Occurred()) SWIG_fail;
50570 }
50571 {
50572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50573 }
50574 return resultobj;
50575 fail:
50576 return NULL;
50577 }
50578
50579
50580 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50581 PyObject *resultobj = 0;
50582 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50583 size_t arg2 ;
50584 wxGBSpan *arg3 = 0 ;
50585 bool result;
50586 void *argp1 = 0 ;
50587 int res1 = 0 ;
50588 size_t val2 ;
50589 int ecode2 = 0 ;
50590 wxGBSpan temp3 ;
50591
50592 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50594 if (!SWIG_IsOK(res1)) {
50595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50596 }
50597 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50598 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50599 if (!SWIG_IsOK(ecode2)) {
50600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50601 }
50602 arg2 = static_cast< size_t >(val2);
50603 {
50604 arg3 = &temp3;
50605 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50606 }
50607 {
50608 PyThreadState* __tstate = wxPyBeginAllowThreads();
50609 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50610 wxPyEndAllowThreads(__tstate);
50611 if (PyErr_Occurred()) SWIG_fail;
50612 }
50613 {
50614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50615 }
50616 return resultobj;
50617 fail:
50618 return NULL;
50619 }
50620
50621
50622 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50623 int argc;
50624 PyObject *argv[4];
50625
50626 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50627 --argc;
50628 if (argc == 3) {
50629 int _v = 0;
50630 {
50631 void *vptr = 0;
50632 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50633 _v = SWIG_CheckState(res);
50634 }
50635 if (!_v) goto check_1;
50636 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50637 }
50638 check_1:
50639
50640 if (argc == 3) {
50641 int _v = 0;
50642 {
50643 void *vptr = 0;
50644 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50645 _v = SWIG_CheckState(res);
50646 }
50647 if (!_v) goto check_2;
50648 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50649 }
50650 check_2:
50651
50652 if (argc == 3) {
50653 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50654 }
50655
50656 fail:
50657 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50658 return NULL;
50659 }
50660
50661
50662 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50663 PyObject *resultobj = 0;
50664 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50665 wxWindow *arg2 = (wxWindow *) 0 ;
50666 wxGBSizerItem *result = 0 ;
50667 void *argp1 = 0 ;
50668 int res1 = 0 ;
50669 void *argp2 = 0 ;
50670 int res2 = 0 ;
50671
50672 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50674 if (!SWIG_IsOK(res1)) {
50675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50676 }
50677 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50678 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50679 if (!SWIG_IsOK(res2)) {
50680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50681 }
50682 arg2 = reinterpret_cast< wxWindow * >(argp2);
50683 {
50684 PyThreadState* __tstate = wxPyBeginAllowThreads();
50685 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50686 wxPyEndAllowThreads(__tstate);
50687 if (PyErr_Occurred()) SWIG_fail;
50688 }
50689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50690 return resultobj;
50691 fail:
50692 return NULL;
50693 }
50694
50695
50696 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50697 PyObject *resultobj = 0;
50698 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50699 wxSizer *arg2 = (wxSizer *) 0 ;
50700 wxGBSizerItem *result = 0 ;
50701 void *argp1 = 0 ;
50702 int res1 = 0 ;
50703 void *argp2 = 0 ;
50704 int res2 = 0 ;
50705
50706 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50708 if (!SWIG_IsOK(res1)) {
50709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50710 }
50711 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50712 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50713 if (!SWIG_IsOK(res2)) {
50714 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50715 }
50716 arg2 = reinterpret_cast< wxSizer * >(argp2);
50717 {
50718 PyThreadState* __tstate = wxPyBeginAllowThreads();
50719 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50720 wxPyEndAllowThreads(__tstate);
50721 if (PyErr_Occurred()) SWIG_fail;
50722 }
50723 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50724 return resultobj;
50725 fail:
50726 return NULL;
50727 }
50728
50729
50730 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50731 int argc;
50732 PyObject *argv[3];
50733
50734 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50735 --argc;
50736 if (argc == 2) {
50737 int _v = 0;
50738 {
50739 void *vptr = 0;
50740 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50741 _v = SWIG_CheckState(res);
50742 }
50743 if (!_v) goto check_1;
50744 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50745 }
50746 check_1:
50747
50748 if (argc == 2) {
50749 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50750 }
50751
50752 fail:
50753 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50754 return NULL;
50755 }
50756
50757
50758 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50759 PyObject *resultobj = 0;
50760 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50761 wxGBPosition *arg2 = 0 ;
50762 wxGBSizerItem *result = 0 ;
50763 void *argp1 = 0 ;
50764 int res1 = 0 ;
50765 wxGBPosition temp2 ;
50766 PyObject * obj0 = 0 ;
50767 PyObject * obj1 = 0 ;
50768 char * kwnames[] = {
50769 (char *) "self",(char *) "pos", NULL
50770 };
50771
50772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50774 if (!SWIG_IsOK(res1)) {
50775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50776 }
50777 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50778 {
50779 arg2 = &temp2;
50780 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50781 }
50782 {
50783 PyThreadState* __tstate = wxPyBeginAllowThreads();
50784 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
50785 wxPyEndAllowThreads(__tstate);
50786 if (PyErr_Occurred()) SWIG_fail;
50787 }
50788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50789 return resultobj;
50790 fail:
50791 return NULL;
50792 }
50793
50794
50795 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50796 PyObject *resultobj = 0;
50797 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50798 wxPoint *arg2 = 0 ;
50799 wxGBSizerItem *result = 0 ;
50800 void *argp1 = 0 ;
50801 int res1 = 0 ;
50802 wxPoint temp2 ;
50803 PyObject * obj0 = 0 ;
50804 PyObject * obj1 = 0 ;
50805 char * kwnames[] = {
50806 (char *) "self",(char *) "pt", NULL
50807 };
50808
50809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
50810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50811 if (!SWIG_IsOK(res1)) {
50812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50813 }
50814 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50815 {
50816 arg2 = &temp2;
50817 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50818 }
50819 {
50820 PyThreadState* __tstate = wxPyBeginAllowThreads();
50821 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
50822 wxPyEndAllowThreads(__tstate);
50823 if (PyErr_Occurred()) SWIG_fail;
50824 }
50825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50826 return resultobj;
50827 fail:
50828 return NULL;
50829 }
50830
50831
50832 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50833 PyObject *resultobj = 0;
50834 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50835 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50836 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
50837 bool result;
50838 void *argp1 = 0 ;
50839 int res1 = 0 ;
50840 void *argp2 = 0 ;
50841 int res2 = 0 ;
50842 void *argp3 = 0 ;
50843 int res3 = 0 ;
50844 PyObject * obj0 = 0 ;
50845 PyObject * obj1 = 0 ;
50846 PyObject * obj2 = 0 ;
50847 char * kwnames[] = {
50848 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
50849 };
50850
50851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50853 if (!SWIG_IsOK(res1)) {
50854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50855 }
50856 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50857 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50858 if (!SWIG_IsOK(res2)) {
50859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50860 }
50861 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50862 if (obj2) {
50863 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50864 if (!SWIG_IsOK(res3)) {
50865 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
50866 }
50867 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
50868 }
50869 {
50870 PyThreadState* __tstate = wxPyBeginAllowThreads();
50871 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
50872 wxPyEndAllowThreads(__tstate);
50873 if (PyErr_Occurred()) SWIG_fail;
50874 }
50875 {
50876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50877 }
50878 return resultobj;
50879 fail:
50880 return NULL;
50881 }
50882
50883
50884 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50885 PyObject *resultobj = 0;
50886 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50887 wxGBPosition *arg2 = 0 ;
50888 wxGBSpan *arg3 = 0 ;
50889 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
50890 bool result;
50891 void *argp1 = 0 ;
50892 int res1 = 0 ;
50893 wxGBPosition temp2 ;
50894 wxGBSpan temp3 ;
50895 void *argp4 = 0 ;
50896 int res4 = 0 ;
50897 PyObject * obj0 = 0 ;
50898 PyObject * obj1 = 0 ;
50899 PyObject * obj2 = 0 ;
50900 PyObject * obj3 = 0 ;
50901 char * kwnames[] = {
50902 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
50903 };
50904
50905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50907 if (!SWIG_IsOK(res1)) {
50908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50909 }
50910 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50911 {
50912 arg2 = &temp2;
50913 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50914 }
50915 {
50916 arg3 = &temp3;
50917 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50918 }
50919 if (obj3) {
50920 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50921 if (!SWIG_IsOK(res4)) {
50922 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
50923 }
50924 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
50925 }
50926 {
50927 PyThreadState* __tstate = wxPyBeginAllowThreads();
50928 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
50929 wxPyEndAllowThreads(__tstate);
50930 if (PyErr_Occurred()) SWIG_fail;
50931 }
50932 {
50933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50934 }
50935 return resultobj;
50936 fail:
50937 return NULL;
50938 }
50939
50940
50941 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50942 PyObject *obj;
50943 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50944 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
50945 return SWIG_Py_Void();
50946 }
50947
50948 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50949 return SWIG_Python_InitShadowInstance(args);
50950 }
50951
50952 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50953 PyObject *resultobj = 0;
50954 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
50955 wxRelationship arg2 ;
50956 wxWindow *arg3 = (wxWindow *) 0 ;
50957 wxEdge arg4 ;
50958 int arg5 = (int) 0 ;
50959 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
50960 void *argp1 = 0 ;
50961 int res1 = 0 ;
50962 int val2 ;
50963 int ecode2 = 0 ;
50964 void *argp3 = 0 ;
50965 int res3 = 0 ;
50966 int val4 ;
50967 int ecode4 = 0 ;
50968 int val5 ;
50969 int ecode5 = 0 ;
50970 int val6 ;
50971 int ecode6 = 0 ;
50972 PyObject * obj0 = 0 ;
50973 PyObject * obj1 = 0 ;
50974 PyObject * obj2 = 0 ;
50975 PyObject * obj3 = 0 ;
50976 PyObject * obj4 = 0 ;
50977 PyObject * obj5 = 0 ;
50978 char * kwnames[] = {
50979 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
50980 };
50981
50982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
50984 if (!SWIG_IsOK(res1)) {
50985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
50986 }
50987 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
50988 ecode2 = SWIG_AsVal_int(obj1, &val2);
50989 if (!SWIG_IsOK(ecode2)) {
50990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
50991 }
50992 arg2 = static_cast< wxRelationship >(val2);
50993 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50994 if (!SWIG_IsOK(res3)) {
50995 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
50996 }
50997 arg3 = reinterpret_cast< wxWindow * >(argp3);
50998 ecode4 = SWIG_AsVal_int(obj3, &val4);
50999 if (!SWIG_IsOK(ecode4)) {
51000 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51001 }
51002 arg4 = static_cast< wxEdge >(val4);
51003 if (obj4) {
51004 ecode5 = SWIG_AsVal_int(obj4, &val5);
51005 if (!SWIG_IsOK(ecode5)) {
51006 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51007 }
51008 arg5 = static_cast< int >(val5);
51009 }
51010 if (obj5) {
51011 ecode6 = SWIG_AsVal_int(obj5, &val6);
51012 if (!SWIG_IsOK(ecode6)) {
51013 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51014 }
51015 arg6 = static_cast< int >(val6);
51016 }
51017 {
51018 PyThreadState* __tstate = wxPyBeginAllowThreads();
51019 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51020 wxPyEndAllowThreads(__tstate);
51021 if (PyErr_Occurred()) SWIG_fail;
51022 }
51023 resultobj = SWIG_Py_Void();
51024 return resultobj;
51025 fail:
51026 return NULL;
51027 }
51028
51029
51030 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51031 PyObject *resultobj = 0;
51032 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51033 wxWindow *arg2 = (wxWindow *) 0 ;
51034 int arg3 = (int) 0 ;
51035 void *argp1 = 0 ;
51036 int res1 = 0 ;
51037 void *argp2 = 0 ;
51038 int res2 = 0 ;
51039 int val3 ;
51040 int ecode3 = 0 ;
51041 PyObject * obj0 = 0 ;
51042 PyObject * obj1 = 0 ;
51043 PyObject * obj2 = 0 ;
51044 char * kwnames[] = {
51045 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51046 };
51047
51048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51050 if (!SWIG_IsOK(res1)) {
51051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51052 }
51053 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51054 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51055 if (!SWIG_IsOK(res2)) {
51056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51057 }
51058 arg2 = reinterpret_cast< wxWindow * >(argp2);
51059 if (obj2) {
51060 ecode3 = SWIG_AsVal_int(obj2, &val3);
51061 if (!SWIG_IsOK(ecode3)) {
51062 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51063 }
51064 arg3 = static_cast< int >(val3);
51065 }
51066 {
51067 PyThreadState* __tstate = wxPyBeginAllowThreads();
51068 (arg1)->LeftOf(arg2,arg3);
51069 wxPyEndAllowThreads(__tstate);
51070 if (PyErr_Occurred()) SWIG_fail;
51071 }
51072 resultobj = SWIG_Py_Void();
51073 return resultobj;
51074 fail:
51075 return NULL;
51076 }
51077
51078
51079 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51080 PyObject *resultobj = 0;
51081 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51082 wxWindow *arg2 = (wxWindow *) 0 ;
51083 int arg3 = (int) 0 ;
51084 void *argp1 = 0 ;
51085 int res1 = 0 ;
51086 void *argp2 = 0 ;
51087 int res2 = 0 ;
51088 int val3 ;
51089 int ecode3 = 0 ;
51090 PyObject * obj0 = 0 ;
51091 PyObject * obj1 = 0 ;
51092 PyObject * obj2 = 0 ;
51093 char * kwnames[] = {
51094 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51095 };
51096
51097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51099 if (!SWIG_IsOK(res1)) {
51100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51101 }
51102 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51103 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51104 if (!SWIG_IsOK(res2)) {
51105 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51106 }
51107 arg2 = reinterpret_cast< wxWindow * >(argp2);
51108 if (obj2) {
51109 ecode3 = SWIG_AsVal_int(obj2, &val3);
51110 if (!SWIG_IsOK(ecode3)) {
51111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51112 }
51113 arg3 = static_cast< int >(val3);
51114 }
51115 {
51116 PyThreadState* __tstate = wxPyBeginAllowThreads();
51117 (arg1)->RightOf(arg2,arg3);
51118 wxPyEndAllowThreads(__tstate);
51119 if (PyErr_Occurred()) SWIG_fail;
51120 }
51121 resultobj = SWIG_Py_Void();
51122 return resultobj;
51123 fail:
51124 return NULL;
51125 }
51126
51127
51128 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51129 PyObject *resultobj = 0;
51130 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51131 wxWindow *arg2 = (wxWindow *) 0 ;
51132 int arg3 = (int) 0 ;
51133 void *argp1 = 0 ;
51134 int res1 = 0 ;
51135 void *argp2 = 0 ;
51136 int res2 = 0 ;
51137 int val3 ;
51138 int ecode3 = 0 ;
51139 PyObject * obj0 = 0 ;
51140 PyObject * obj1 = 0 ;
51141 PyObject * obj2 = 0 ;
51142 char * kwnames[] = {
51143 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51144 };
51145
51146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51148 if (!SWIG_IsOK(res1)) {
51149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51150 }
51151 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51152 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51153 if (!SWIG_IsOK(res2)) {
51154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51155 }
51156 arg2 = reinterpret_cast< wxWindow * >(argp2);
51157 if (obj2) {
51158 ecode3 = SWIG_AsVal_int(obj2, &val3);
51159 if (!SWIG_IsOK(ecode3)) {
51160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51161 }
51162 arg3 = static_cast< int >(val3);
51163 }
51164 {
51165 PyThreadState* __tstate = wxPyBeginAllowThreads();
51166 (arg1)->Above(arg2,arg3);
51167 wxPyEndAllowThreads(__tstate);
51168 if (PyErr_Occurred()) SWIG_fail;
51169 }
51170 resultobj = SWIG_Py_Void();
51171 return resultobj;
51172 fail:
51173 return NULL;
51174 }
51175
51176
51177 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51178 PyObject *resultobj = 0;
51179 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51180 wxWindow *arg2 = (wxWindow *) 0 ;
51181 int arg3 = (int) 0 ;
51182 void *argp1 = 0 ;
51183 int res1 = 0 ;
51184 void *argp2 = 0 ;
51185 int res2 = 0 ;
51186 int val3 ;
51187 int ecode3 = 0 ;
51188 PyObject * obj0 = 0 ;
51189 PyObject * obj1 = 0 ;
51190 PyObject * obj2 = 0 ;
51191 char * kwnames[] = {
51192 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51193 };
51194
51195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51197 if (!SWIG_IsOK(res1)) {
51198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51199 }
51200 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51201 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51202 if (!SWIG_IsOK(res2)) {
51203 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51204 }
51205 arg2 = reinterpret_cast< wxWindow * >(argp2);
51206 if (obj2) {
51207 ecode3 = SWIG_AsVal_int(obj2, &val3);
51208 if (!SWIG_IsOK(ecode3)) {
51209 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51210 }
51211 arg3 = static_cast< int >(val3);
51212 }
51213 {
51214 PyThreadState* __tstate = wxPyBeginAllowThreads();
51215 (arg1)->Below(arg2,arg3);
51216 wxPyEndAllowThreads(__tstate);
51217 if (PyErr_Occurred()) SWIG_fail;
51218 }
51219 resultobj = SWIG_Py_Void();
51220 return resultobj;
51221 fail:
51222 return NULL;
51223 }
51224
51225
51226 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51227 PyObject *resultobj = 0;
51228 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51229 wxWindow *arg2 = (wxWindow *) 0 ;
51230 wxEdge arg3 ;
51231 int arg4 = (int) 0 ;
51232 void *argp1 = 0 ;
51233 int res1 = 0 ;
51234 void *argp2 = 0 ;
51235 int res2 = 0 ;
51236 int val3 ;
51237 int ecode3 = 0 ;
51238 int val4 ;
51239 int ecode4 = 0 ;
51240 PyObject * obj0 = 0 ;
51241 PyObject * obj1 = 0 ;
51242 PyObject * obj2 = 0 ;
51243 PyObject * obj3 = 0 ;
51244 char * kwnames[] = {
51245 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51246 };
51247
51248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51250 if (!SWIG_IsOK(res1)) {
51251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51252 }
51253 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51254 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51255 if (!SWIG_IsOK(res2)) {
51256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51257 }
51258 arg2 = reinterpret_cast< wxWindow * >(argp2);
51259 ecode3 = SWIG_AsVal_int(obj2, &val3);
51260 if (!SWIG_IsOK(ecode3)) {
51261 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51262 }
51263 arg3 = static_cast< wxEdge >(val3);
51264 if (obj3) {
51265 ecode4 = SWIG_AsVal_int(obj3, &val4);
51266 if (!SWIG_IsOK(ecode4)) {
51267 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51268 }
51269 arg4 = static_cast< int >(val4);
51270 }
51271 {
51272 PyThreadState* __tstate = wxPyBeginAllowThreads();
51273 (arg1)->SameAs(arg2,arg3,arg4);
51274 wxPyEndAllowThreads(__tstate);
51275 if (PyErr_Occurred()) SWIG_fail;
51276 }
51277 resultobj = SWIG_Py_Void();
51278 return resultobj;
51279 fail:
51280 return NULL;
51281 }
51282
51283
51284 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51285 PyObject *resultobj = 0;
51286 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51287 wxWindow *arg2 = (wxWindow *) 0 ;
51288 wxEdge arg3 ;
51289 int arg4 ;
51290 void *argp1 = 0 ;
51291 int res1 = 0 ;
51292 void *argp2 = 0 ;
51293 int res2 = 0 ;
51294 int val3 ;
51295 int ecode3 = 0 ;
51296 int val4 ;
51297 int ecode4 = 0 ;
51298 PyObject * obj0 = 0 ;
51299 PyObject * obj1 = 0 ;
51300 PyObject * obj2 = 0 ;
51301 PyObject * obj3 = 0 ;
51302 char * kwnames[] = {
51303 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51304 };
51305
51306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51308 if (!SWIG_IsOK(res1)) {
51309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51310 }
51311 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51312 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51313 if (!SWIG_IsOK(res2)) {
51314 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51315 }
51316 arg2 = reinterpret_cast< wxWindow * >(argp2);
51317 ecode3 = SWIG_AsVal_int(obj2, &val3);
51318 if (!SWIG_IsOK(ecode3)) {
51319 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51320 }
51321 arg3 = static_cast< wxEdge >(val3);
51322 ecode4 = SWIG_AsVal_int(obj3, &val4);
51323 if (!SWIG_IsOK(ecode4)) {
51324 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51325 }
51326 arg4 = static_cast< int >(val4);
51327 {
51328 PyThreadState* __tstate = wxPyBeginAllowThreads();
51329 (arg1)->PercentOf(arg2,arg3,arg4);
51330 wxPyEndAllowThreads(__tstate);
51331 if (PyErr_Occurred()) SWIG_fail;
51332 }
51333 resultobj = SWIG_Py_Void();
51334 return resultobj;
51335 fail:
51336 return NULL;
51337 }
51338
51339
51340 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51341 PyObject *resultobj = 0;
51342 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51343 int arg2 ;
51344 void *argp1 = 0 ;
51345 int res1 = 0 ;
51346 int val2 ;
51347 int ecode2 = 0 ;
51348 PyObject * obj0 = 0 ;
51349 PyObject * obj1 = 0 ;
51350 char * kwnames[] = {
51351 (char *) "self",(char *) "val", NULL
51352 };
51353
51354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51356 if (!SWIG_IsOK(res1)) {
51357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51358 }
51359 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51360 ecode2 = SWIG_AsVal_int(obj1, &val2);
51361 if (!SWIG_IsOK(ecode2)) {
51362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51363 }
51364 arg2 = static_cast< int >(val2);
51365 {
51366 PyThreadState* __tstate = wxPyBeginAllowThreads();
51367 (arg1)->Absolute(arg2);
51368 wxPyEndAllowThreads(__tstate);
51369 if (PyErr_Occurred()) SWIG_fail;
51370 }
51371 resultobj = SWIG_Py_Void();
51372 return resultobj;
51373 fail:
51374 return NULL;
51375 }
51376
51377
51378 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51379 PyObject *resultobj = 0;
51380 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51381 void *argp1 = 0 ;
51382 int res1 = 0 ;
51383 PyObject *swig_obj[1] ;
51384
51385 if (!args) SWIG_fail;
51386 swig_obj[0] = args;
51387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51388 if (!SWIG_IsOK(res1)) {
51389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51390 }
51391 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51392 {
51393 PyThreadState* __tstate = wxPyBeginAllowThreads();
51394 (arg1)->Unconstrained();
51395 wxPyEndAllowThreads(__tstate);
51396 if (PyErr_Occurred()) SWIG_fail;
51397 }
51398 resultobj = SWIG_Py_Void();
51399 return resultobj;
51400 fail:
51401 return NULL;
51402 }
51403
51404
51405 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51406 PyObject *resultobj = 0;
51407 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51408 void *argp1 = 0 ;
51409 int res1 = 0 ;
51410 PyObject *swig_obj[1] ;
51411
51412 if (!args) SWIG_fail;
51413 swig_obj[0] = args;
51414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51415 if (!SWIG_IsOK(res1)) {
51416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51417 }
51418 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51419 {
51420 PyThreadState* __tstate = wxPyBeginAllowThreads();
51421 (arg1)->AsIs();
51422 wxPyEndAllowThreads(__tstate);
51423 if (PyErr_Occurred()) SWIG_fail;
51424 }
51425 resultobj = SWIG_Py_Void();
51426 return resultobj;
51427 fail:
51428 return NULL;
51429 }
51430
51431
51432 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51433 PyObject *resultobj = 0;
51434 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51435 wxWindow *result = 0 ;
51436 void *argp1 = 0 ;
51437 int res1 = 0 ;
51438 PyObject *swig_obj[1] ;
51439
51440 if (!args) SWIG_fail;
51441 swig_obj[0] = args;
51442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51443 if (!SWIG_IsOK(res1)) {
51444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51445 }
51446 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51447 {
51448 PyThreadState* __tstate = wxPyBeginAllowThreads();
51449 result = (wxWindow *)(arg1)->GetOtherWindow();
51450 wxPyEndAllowThreads(__tstate);
51451 if (PyErr_Occurred()) SWIG_fail;
51452 }
51453 {
51454 resultobj = wxPyMake_wxObject(result, 0);
51455 }
51456 return resultobj;
51457 fail:
51458 return NULL;
51459 }
51460
51461
51462 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51463 PyObject *resultobj = 0;
51464 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51465 wxEdge result;
51466 void *argp1 = 0 ;
51467 int res1 = 0 ;
51468 PyObject *swig_obj[1] ;
51469
51470 if (!args) SWIG_fail;
51471 swig_obj[0] = args;
51472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51473 if (!SWIG_IsOK(res1)) {
51474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51475 }
51476 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51477 {
51478 PyThreadState* __tstate = wxPyBeginAllowThreads();
51479 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51480 wxPyEndAllowThreads(__tstate);
51481 if (PyErr_Occurred()) SWIG_fail;
51482 }
51483 resultobj = SWIG_From_int(static_cast< int >(result));
51484 return resultobj;
51485 fail:
51486 return NULL;
51487 }
51488
51489
51490 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51491 PyObject *resultobj = 0;
51492 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51493 wxEdge arg2 ;
51494 void *argp1 = 0 ;
51495 int res1 = 0 ;
51496 int val2 ;
51497 int ecode2 = 0 ;
51498 PyObject * obj0 = 0 ;
51499 PyObject * obj1 = 0 ;
51500 char * kwnames[] = {
51501 (char *) "self",(char *) "which", NULL
51502 };
51503
51504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51506 if (!SWIG_IsOK(res1)) {
51507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51508 }
51509 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51510 ecode2 = SWIG_AsVal_int(obj1, &val2);
51511 if (!SWIG_IsOK(ecode2)) {
51512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51513 }
51514 arg2 = static_cast< wxEdge >(val2);
51515 {
51516 PyThreadState* __tstate = wxPyBeginAllowThreads();
51517 (arg1)->SetEdge(arg2);
51518 wxPyEndAllowThreads(__tstate);
51519 if (PyErr_Occurred()) SWIG_fail;
51520 }
51521 resultobj = SWIG_Py_Void();
51522 return resultobj;
51523 fail:
51524 return NULL;
51525 }
51526
51527
51528 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51529 PyObject *resultobj = 0;
51530 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51531 int arg2 ;
51532 void *argp1 = 0 ;
51533 int res1 = 0 ;
51534 int val2 ;
51535 int ecode2 = 0 ;
51536 PyObject * obj0 = 0 ;
51537 PyObject * obj1 = 0 ;
51538 char * kwnames[] = {
51539 (char *) "self",(char *) "v", NULL
51540 };
51541
51542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51544 if (!SWIG_IsOK(res1)) {
51545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51546 }
51547 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51548 ecode2 = SWIG_AsVal_int(obj1, &val2);
51549 if (!SWIG_IsOK(ecode2)) {
51550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51551 }
51552 arg2 = static_cast< int >(val2);
51553 {
51554 PyThreadState* __tstate = wxPyBeginAllowThreads();
51555 (arg1)->SetValue(arg2);
51556 wxPyEndAllowThreads(__tstate);
51557 if (PyErr_Occurred()) SWIG_fail;
51558 }
51559 resultobj = SWIG_Py_Void();
51560 return resultobj;
51561 fail:
51562 return NULL;
51563 }
51564
51565
51566 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51567 PyObject *resultobj = 0;
51568 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51569 int result;
51570 void *argp1 = 0 ;
51571 int res1 = 0 ;
51572 PyObject *swig_obj[1] ;
51573
51574 if (!args) SWIG_fail;
51575 swig_obj[0] = args;
51576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51577 if (!SWIG_IsOK(res1)) {
51578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51579 }
51580 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51581 {
51582 PyThreadState* __tstate = wxPyBeginAllowThreads();
51583 result = (int)(arg1)->GetMargin();
51584 wxPyEndAllowThreads(__tstate);
51585 if (PyErr_Occurred()) SWIG_fail;
51586 }
51587 resultobj = SWIG_From_int(static_cast< int >(result));
51588 return resultobj;
51589 fail:
51590 return NULL;
51591 }
51592
51593
51594 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51595 PyObject *resultobj = 0;
51596 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51597 int arg2 ;
51598 void *argp1 = 0 ;
51599 int res1 = 0 ;
51600 int val2 ;
51601 int ecode2 = 0 ;
51602 PyObject * obj0 = 0 ;
51603 PyObject * obj1 = 0 ;
51604 char * kwnames[] = {
51605 (char *) "self",(char *) "m", NULL
51606 };
51607
51608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51610 if (!SWIG_IsOK(res1)) {
51611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51612 }
51613 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51614 ecode2 = SWIG_AsVal_int(obj1, &val2);
51615 if (!SWIG_IsOK(ecode2)) {
51616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51617 }
51618 arg2 = static_cast< int >(val2);
51619 {
51620 PyThreadState* __tstate = wxPyBeginAllowThreads();
51621 (arg1)->SetMargin(arg2);
51622 wxPyEndAllowThreads(__tstate);
51623 if (PyErr_Occurred()) SWIG_fail;
51624 }
51625 resultobj = SWIG_Py_Void();
51626 return resultobj;
51627 fail:
51628 return NULL;
51629 }
51630
51631
51632 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51633 PyObject *resultobj = 0;
51634 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51635 int result;
51636 void *argp1 = 0 ;
51637 int res1 = 0 ;
51638 PyObject *swig_obj[1] ;
51639
51640 if (!args) SWIG_fail;
51641 swig_obj[0] = args;
51642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51643 if (!SWIG_IsOK(res1)) {
51644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51645 }
51646 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51647 {
51648 PyThreadState* __tstate = wxPyBeginAllowThreads();
51649 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51650 wxPyEndAllowThreads(__tstate);
51651 if (PyErr_Occurred()) SWIG_fail;
51652 }
51653 resultobj = SWIG_From_int(static_cast< int >(result));
51654 return resultobj;
51655 fail:
51656 return NULL;
51657 }
51658
51659
51660 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51661 PyObject *resultobj = 0;
51662 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51663 int result;
51664 void *argp1 = 0 ;
51665 int res1 = 0 ;
51666 PyObject *swig_obj[1] ;
51667
51668 if (!args) SWIG_fail;
51669 swig_obj[0] = args;
51670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51671 if (!SWIG_IsOK(res1)) {
51672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51673 }
51674 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51675 {
51676 PyThreadState* __tstate = wxPyBeginAllowThreads();
51677 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51678 wxPyEndAllowThreads(__tstate);
51679 if (PyErr_Occurred()) SWIG_fail;
51680 }
51681 resultobj = SWIG_From_int(static_cast< int >(result));
51682 return resultobj;
51683 fail:
51684 return NULL;
51685 }
51686
51687
51688 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51689 PyObject *resultobj = 0;
51690 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51691 int result;
51692 void *argp1 = 0 ;
51693 int res1 = 0 ;
51694 PyObject *swig_obj[1] ;
51695
51696 if (!args) SWIG_fail;
51697 swig_obj[0] = args;
51698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51699 if (!SWIG_IsOK(res1)) {
51700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51701 }
51702 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51703 {
51704 PyThreadState* __tstate = wxPyBeginAllowThreads();
51705 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51706 wxPyEndAllowThreads(__tstate);
51707 if (PyErr_Occurred()) SWIG_fail;
51708 }
51709 resultobj = SWIG_From_int(static_cast< int >(result));
51710 return resultobj;
51711 fail:
51712 return NULL;
51713 }
51714
51715
51716 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51717 PyObject *resultobj = 0;
51718 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51719 bool result;
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_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51729 }
51730 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51731 {
51732 PyThreadState* __tstate = wxPyBeginAllowThreads();
51733 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51734 wxPyEndAllowThreads(__tstate);
51735 if (PyErr_Occurred()) SWIG_fail;
51736 }
51737 {
51738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51739 }
51740 return resultobj;
51741 fail:
51742 return NULL;
51743 }
51744
51745
51746 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51747 PyObject *resultobj = 0;
51748 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51749 bool arg2 ;
51750 void *argp1 = 0 ;
51751 int res1 = 0 ;
51752 bool val2 ;
51753 int ecode2 = 0 ;
51754 PyObject * obj0 = 0 ;
51755 PyObject * obj1 = 0 ;
51756 char * kwnames[] = {
51757 (char *) "self",(char *) "d", NULL
51758 };
51759
51760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51762 if (!SWIG_IsOK(res1)) {
51763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51764 }
51765 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51766 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51767 if (!SWIG_IsOK(ecode2)) {
51768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
51769 }
51770 arg2 = static_cast< bool >(val2);
51771 {
51772 PyThreadState* __tstate = wxPyBeginAllowThreads();
51773 (arg1)->SetDone(arg2);
51774 wxPyEndAllowThreads(__tstate);
51775 if (PyErr_Occurred()) SWIG_fail;
51776 }
51777 resultobj = SWIG_Py_Void();
51778 return resultobj;
51779 fail:
51780 return NULL;
51781 }
51782
51783
51784 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51785 PyObject *resultobj = 0;
51786 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51787 wxRelationship result;
51788 void *argp1 = 0 ;
51789 int res1 = 0 ;
51790 PyObject *swig_obj[1] ;
51791
51792 if (!args) SWIG_fail;
51793 swig_obj[0] = args;
51794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51795 if (!SWIG_IsOK(res1)) {
51796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51797 }
51798 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51799 {
51800 PyThreadState* __tstate = wxPyBeginAllowThreads();
51801 result = (wxRelationship)(arg1)->GetRelationship();
51802 wxPyEndAllowThreads(__tstate);
51803 if (PyErr_Occurred()) SWIG_fail;
51804 }
51805 resultobj = SWIG_From_int(static_cast< int >(result));
51806 return resultobj;
51807 fail:
51808 return NULL;
51809 }
51810
51811
51812 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51813 PyObject *resultobj = 0;
51814 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51815 wxRelationship arg2 ;
51816 void *argp1 = 0 ;
51817 int res1 = 0 ;
51818 int val2 ;
51819 int ecode2 = 0 ;
51820 PyObject * obj0 = 0 ;
51821 PyObject * obj1 = 0 ;
51822 char * kwnames[] = {
51823 (char *) "self",(char *) "r", NULL
51824 };
51825
51826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
51827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51828 if (!SWIG_IsOK(res1)) {
51829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51830 }
51831 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51832 ecode2 = SWIG_AsVal_int(obj1, &val2);
51833 if (!SWIG_IsOK(ecode2)) {
51834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
51835 }
51836 arg2 = static_cast< wxRelationship >(val2);
51837 {
51838 PyThreadState* __tstate = wxPyBeginAllowThreads();
51839 (arg1)->SetRelationship(arg2);
51840 wxPyEndAllowThreads(__tstate);
51841 if (PyErr_Occurred()) SWIG_fail;
51842 }
51843 resultobj = SWIG_Py_Void();
51844 return resultobj;
51845 fail:
51846 return NULL;
51847 }
51848
51849
51850 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51851 PyObject *resultobj = 0;
51852 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51853 wxWindow *arg2 = (wxWindow *) 0 ;
51854 bool result;
51855 void *argp1 = 0 ;
51856 int res1 = 0 ;
51857 void *argp2 = 0 ;
51858 int res2 = 0 ;
51859 PyObject * obj0 = 0 ;
51860 PyObject * obj1 = 0 ;
51861 char * kwnames[] = {
51862 (char *) "self",(char *) "otherW", NULL
51863 };
51864
51865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
51866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51867 if (!SWIG_IsOK(res1)) {
51868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51869 }
51870 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51871 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51872 if (!SWIG_IsOK(res2)) {
51873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
51874 }
51875 arg2 = reinterpret_cast< wxWindow * >(argp2);
51876 {
51877 PyThreadState* __tstate = wxPyBeginAllowThreads();
51878 result = (bool)(arg1)->ResetIfWin(arg2);
51879 wxPyEndAllowThreads(__tstate);
51880 if (PyErr_Occurred()) SWIG_fail;
51881 }
51882 {
51883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51884 }
51885 return resultobj;
51886 fail:
51887 return NULL;
51888 }
51889
51890
51891 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51892 PyObject *resultobj = 0;
51893 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51894 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
51895 wxWindow *arg3 = (wxWindow *) 0 ;
51896 bool result;
51897 void *argp1 = 0 ;
51898 int res1 = 0 ;
51899 void *argp2 = 0 ;
51900 int res2 = 0 ;
51901 void *argp3 = 0 ;
51902 int res3 = 0 ;
51903 PyObject * obj0 = 0 ;
51904 PyObject * obj1 = 0 ;
51905 PyObject * obj2 = 0 ;
51906 char * kwnames[] = {
51907 (char *) "self",(char *) "constraints",(char *) "win", NULL
51908 };
51909
51910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51912 if (!SWIG_IsOK(res1)) {
51913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51914 }
51915 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51916 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51917 if (!SWIG_IsOK(res2)) {
51918 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
51919 }
51920 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
51921 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51922 if (!SWIG_IsOK(res3)) {
51923 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
51924 }
51925 arg3 = reinterpret_cast< wxWindow * >(argp3);
51926 {
51927 PyThreadState* __tstate = wxPyBeginAllowThreads();
51928 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
51929 wxPyEndAllowThreads(__tstate);
51930 if (PyErr_Occurred()) SWIG_fail;
51931 }
51932 {
51933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51934 }
51935 return resultobj;
51936 fail:
51937 return NULL;
51938 }
51939
51940
51941 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51942 PyObject *resultobj = 0;
51943 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51944 wxEdge arg2 ;
51945 wxWindow *arg3 = (wxWindow *) 0 ;
51946 wxWindow *arg4 = (wxWindow *) 0 ;
51947 int result;
51948 void *argp1 = 0 ;
51949 int res1 = 0 ;
51950 int val2 ;
51951 int ecode2 = 0 ;
51952 void *argp3 = 0 ;
51953 int res3 = 0 ;
51954 void *argp4 = 0 ;
51955 int res4 = 0 ;
51956 PyObject * obj0 = 0 ;
51957 PyObject * obj1 = 0 ;
51958 PyObject * obj2 = 0 ;
51959 PyObject * obj3 = 0 ;
51960 char * kwnames[] = {
51961 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
51962 };
51963
51964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51966 if (!SWIG_IsOK(res1)) {
51967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51968 }
51969 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51970 ecode2 = SWIG_AsVal_int(obj1, &val2);
51971 if (!SWIG_IsOK(ecode2)) {
51972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51973 }
51974 arg2 = static_cast< wxEdge >(val2);
51975 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51976 if (!SWIG_IsOK(res3)) {
51977 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
51978 }
51979 arg3 = reinterpret_cast< wxWindow * >(argp3);
51980 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
51981 if (!SWIG_IsOK(res4)) {
51982 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
51983 }
51984 arg4 = reinterpret_cast< wxWindow * >(argp4);
51985 {
51986 PyThreadState* __tstate = wxPyBeginAllowThreads();
51987 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
51988 wxPyEndAllowThreads(__tstate);
51989 if (PyErr_Occurred()) SWIG_fail;
51990 }
51991 resultobj = SWIG_From_int(static_cast< int >(result));
51992 return resultobj;
51993 fail:
51994 return NULL;
51995 }
51996
51997
51998 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51999 PyObject *obj;
52000 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52001 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52002 return SWIG_Py_Void();
52003 }
52004
52005 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52006 PyObject *resultobj = 0;
52007 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52008 wxIndividualLayoutConstraint *result = 0 ;
52009 void *argp1 = 0 ;
52010 int res1 = 0 ;
52011 PyObject *swig_obj[1] ;
52012
52013 if (!args) SWIG_fail;
52014 swig_obj[0] = args;
52015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52016 if (!SWIG_IsOK(res1)) {
52017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52018 }
52019 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52020 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52021 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52022 return resultobj;
52023 fail:
52024 return NULL;
52025 }
52026
52027
52028 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52029 PyObject *resultobj = 0;
52030 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52031 wxIndividualLayoutConstraint *result = 0 ;
52032 void *argp1 = 0 ;
52033 int res1 = 0 ;
52034 PyObject *swig_obj[1] ;
52035
52036 if (!args) SWIG_fail;
52037 swig_obj[0] = args;
52038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52039 if (!SWIG_IsOK(res1)) {
52040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52041 }
52042 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52043 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52045 return resultobj;
52046 fail:
52047 return NULL;
52048 }
52049
52050
52051 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52052 PyObject *resultobj = 0;
52053 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52054 wxIndividualLayoutConstraint *result = 0 ;
52055 void *argp1 = 0 ;
52056 int res1 = 0 ;
52057 PyObject *swig_obj[1] ;
52058
52059 if (!args) SWIG_fail;
52060 swig_obj[0] = args;
52061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52062 if (!SWIG_IsOK(res1)) {
52063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52064 }
52065 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52066 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52068 return resultobj;
52069 fail:
52070 return NULL;
52071 }
52072
52073
52074 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52075 PyObject *resultobj = 0;
52076 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52077 wxIndividualLayoutConstraint *result = 0 ;
52078 void *argp1 = 0 ;
52079 int res1 = 0 ;
52080 PyObject *swig_obj[1] ;
52081
52082 if (!args) SWIG_fail;
52083 swig_obj[0] = args;
52084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52085 if (!SWIG_IsOK(res1)) {
52086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52087 }
52088 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52089 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52091 return resultobj;
52092 fail:
52093 return NULL;
52094 }
52095
52096
52097 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52098 PyObject *resultobj = 0;
52099 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52100 wxIndividualLayoutConstraint *result = 0 ;
52101 void *argp1 = 0 ;
52102 int res1 = 0 ;
52103 PyObject *swig_obj[1] ;
52104
52105 if (!args) SWIG_fail;
52106 swig_obj[0] = args;
52107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52108 if (!SWIG_IsOK(res1)) {
52109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52110 }
52111 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52112 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52114 return resultobj;
52115 fail:
52116 return NULL;
52117 }
52118
52119
52120 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52121 PyObject *resultobj = 0;
52122 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52123 wxIndividualLayoutConstraint *result = 0 ;
52124 void *argp1 = 0 ;
52125 int res1 = 0 ;
52126 PyObject *swig_obj[1] ;
52127
52128 if (!args) SWIG_fail;
52129 swig_obj[0] = args;
52130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52131 if (!SWIG_IsOK(res1)) {
52132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52133 }
52134 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52135 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52137 return resultobj;
52138 fail:
52139 return NULL;
52140 }
52141
52142
52143 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52144 PyObject *resultobj = 0;
52145 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52146 wxIndividualLayoutConstraint *result = 0 ;
52147 void *argp1 = 0 ;
52148 int res1 = 0 ;
52149 PyObject *swig_obj[1] ;
52150
52151 if (!args) SWIG_fail;
52152 swig_obj[0] = args;
52153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52154 if (!SWIG_IsOK(res1)) {
52155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52156 }
52157 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52158 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52160 return resultobj;
52161 fail:
52162 return NULL;
52163 }
52164
52165
52166 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52167 PyObject *resultobj = 0;
52168 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52169 wxIndividualLayoutConstraint *result = 0 ;
52170 void *argp1 = 0 ;
52171 int res1 = 0 ;
52172 PyObject *swig_obj[1] ;
52173
52174 if (!args) SWIG_fail;
52175 swig_obj[0] = args;
52176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52177 if (!SWIG_IsOK(res1)) {
52178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52179 }
52180 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52181 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52183 return resultobj;
52184 fail:
52185 return NULL;
52186 }
52187
52188
52189 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52190 PyObject *resultobj = 0;
52191 wxLayoutConstraints *result = 0 ;
52192
52193 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52194 {
52195 PyThreadState* __tstate = wxPyBeginAllowThreads();
52196 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52197 wxPyEndAllowThreads(__tstate);
52198 if (PyErr_Occurred()) SWIG_fail;
52199 }
52200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52201 return resultobj;
52202 fail:
52203 return NULL;
52204 }
52205
52206
52207 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52208 PyObject *resultobj = 0;
52209 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52210 void *argp1 = 0 ;
52211 int res1 = 0 ;
52212 PyObject *swig_obj[1] ;
52213
52214 if (!args) SWIG_fail;
52215 swig_obj[0] = args;
52216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52217 if (!SWIG_IsOK(res1)) {
52218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52219 }
52220 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52221 {
52222 PyThreadState* __tstate = wxPyBeginAllowThreads();
52223 delete arg1;
52224
52225 wxPyEndAllowThreads(__tstate);
52226 if (PyErr_Occurred()) SWIG_fail;
52227 }
52228 resultobj = SWIG_Py_Void();
52229 return resultobj;
52230 fail:
52231 return NULL;
52232 }
52233
52234
52235 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52236 PyObject *resultobj = 0;
52237 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52238 wxWindow *arg2 = (wxWindow *) 0 ;
52239 int *arg3 = (int *) 0 ;
52240 bool result;
52241 void *argp1 = 0 ;
52242 int res1 = 0 ;
52243 void *argp2 = 0 ;
52244 int res2 = 0 ;
52245 int temp3 ;
52246 int res3 = SWIG_TMPOBJ ;
52247 PyObject * obj0 = 0 ;
52248 PyObject * obj1 = 0 ;
52249 char * kwnames[] = {
52250 (char *) "self",(char *) "win", NULL
52251 };
52252
52253 arg3 = &temp3;
52254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52256 if (!SWIG_IsOK(res1)) {
52257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52258 }
52259 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52260 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52261 if (!SWIG_IsOK(res2)) {
52262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52263 }
52264 arg2 = reinterpret_cast< wxWindow * >(argp2);
52265 {
52266 PyThreadState* __tstate = wxPyBeginAllowThreads();
52267 result = (bool)(arg1)->SatisfyConstraints(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 if (SWIG_IsTmpObj(res3)) {
52275 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52276 } else {
52277 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52278 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52279 }
52280 return resultobj;
52281 fail:
52282 return NULL;
52283 }
52284
52285
52286 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52287 PyObject *resultobj = 0;
52288 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52289 bool result;
52290 void *argp1 = 0 ;
52291 int res1 = 0 ;
52292 PyObject *swig_obj[1] ;
52293
52294 if (!args) SWIG_fail;
52295 swig_obj[0] = args;
52296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52297 if (!SWIG_IsOK(res1)) {
52298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52299 }
52300 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52301 {
52302 PyThreadState* __tstate = wxPyBeginAllowThreads();
52303 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52304 wxPyEndAllowThreads(__tstate);
52305 if (PyErr_Occurred()) SWIG_fail;
52306 }
52307 {
52308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52309 }
52310 return resultobj;
52311 fail:
52312 return NULL;
52313 }
52314
52315
52316 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52317 PyObject *obj;
52318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52319 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52320 return SWIG_Py_Void();
52321 }
52322
52323 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52324 return SWIG_Python_InitShadowInstance(args);
52325 }
52326
52327 static PyMethodDef SwigMethods[] = {
52328 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52329 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
52330 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52331 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52332 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52333 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52334 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52335 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52336 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52337 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52338 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52339 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52340 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52341 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52342 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52343 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52344 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52345 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52346 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52347 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52348 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52349 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52350 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52351 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52352 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52353 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52354 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52355 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52356 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52357 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52358 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52359 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52360 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52361 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52362 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52363 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52364 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52365 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52366 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52367 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52368 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52369 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52370 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52371 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52372 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52373 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52374 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52375 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52376 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52377 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52378 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52379 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52380 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52381 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52382 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52383 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52384 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52385 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52386 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52387 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52388 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52389 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52390 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52391 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52392 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52393 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52394 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52395 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52396 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52397 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52398 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52399 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52400 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52401 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52402 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52403 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52404 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52405 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52406 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52407 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52408 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52409 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52410 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52411 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52412 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52413 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52414 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52415 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52416 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52417 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52418 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52419 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52420 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52421 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52422 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52423 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52424 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52425 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52426 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52427 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52428 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52429 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52430 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52431 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52432 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52433 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52434 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52435 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52436 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52437 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52438 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52439 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52440 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52441 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52442 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52443 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52444 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52445 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52446 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52447 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52448 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52449 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52450 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52451 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52452 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52453 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52454 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52455 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52456 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52457 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52458 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52459 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52460 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52461 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52462 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52463 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52464 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52465 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52466 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52467 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52468 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52469 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52470 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52471 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52472 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52473 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52474 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52475 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52476 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52477 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52478 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52479 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52480 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52481 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52482 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52483 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52484 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52485 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52486 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52487 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52488 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52489 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52490 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52491 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52492 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52493 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52494 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52495 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52496 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52497 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52498 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52499 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52500 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52501 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52502 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52503 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52504 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52505 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52506 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52507 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52508 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52509 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52510 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52511 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52512 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52513 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52514 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52515 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52516 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52517 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52518 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52519 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52520 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52521 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52522 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52523 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52524 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52525 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52526 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52527 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52528 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52529 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52530 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52531 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52532 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52533 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52534 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52535 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52536 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52537 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52538 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52539 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52540 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52541 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52542 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52543 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52544 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52545 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52546 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52547 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52548 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52549 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52550 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52551 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52552 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52553 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52554 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52555 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52556 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52557 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52558 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52559 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52560 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52561 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52562 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52563 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52564 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52565 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52566 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52567 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52568 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52569 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52570 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52571 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52572 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52573 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52574 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52575 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52576 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52577 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52578 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52579 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52580 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52581 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52582 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52583 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52584 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52585 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52586 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52587 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52588 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52589 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52590 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52591 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52592 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52593 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52594 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52595 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52596 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52597 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52598 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52599 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52600 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52601 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52602 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52603 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52604 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52605 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52606 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52607 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52608 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52609 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52610 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52611 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52612 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52613 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52614 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52615 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52616 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52617 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52618 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52619 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52620 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52621 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52622 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52623 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52624 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52625 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52626 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52627 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52628 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52629 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52630 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52631 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52632 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52633 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52634 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52635 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52636 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52637 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52638 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52639 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52640 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52641 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52642 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52643 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52644 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52645 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52646 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52647 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52648 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52649 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52650 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52651 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52652 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52653 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52654 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52655 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52656 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52657 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52658 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52659 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52660 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52661 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52662 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52663 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52664 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52665 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52666 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52667 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52668 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52669 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52670 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52671 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52672 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52673 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52674 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52675 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52676 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52677 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52678 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52679 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52680 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52681 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52682 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52683 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52684 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52685 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52686 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52687 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52688 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52689 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52690 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52691 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52692 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52693 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52694 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52695 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52696 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52697 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52698 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52699 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52700 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52701 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52702 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52703 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52704 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52705 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52706 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52707 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52708 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52709 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52710 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52711 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52712 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52713 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52714 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52715 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52716 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52717 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52718 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52719 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52720 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52721 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52722 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52723 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52724 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52725 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52726 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52727 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52728 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52729 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52730 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52731 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52732 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52733 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52734 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52735 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52736 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52737 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52738 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52739 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52740 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52741 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52742 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52743 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52744 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52745 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52746 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52747 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52748 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52749 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52750 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52751 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52752 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52753 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52754 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52755 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52756 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52757 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52758 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52759 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52760 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52761 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
52762 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
52763 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
52764 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
52765 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
52766 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
52767 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
52768 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
52769 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52770 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
52771 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
52772 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
52773 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
52774 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
52775 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52776 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
52777 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
52778 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52779 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52780 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
52781 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
52782 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52783 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
52784 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
52785 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52786 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52787 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
52788 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
52789 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52790 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
52791 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
52792 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
52793 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
52794 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
52795 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
52796 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
52797 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
52798 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
52799 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
52800 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
52801 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
52802 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
52803 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
52804 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
52805 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
52806 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
52807 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
52808 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
52809 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
52810 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
52811 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
52812 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
52813 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
52814 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
52815 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
52816 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
52817 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
52818 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
52819 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
52820 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52821 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
52822 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
52823 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
52824 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
52825 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
52826 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
52827 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
52828 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
52829 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
52830 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
52831 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
52832 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
52833 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
52834 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
52835 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
52836 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
52837 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
52838 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
52839 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
52840 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
52841 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
52842 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
52843 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
52844 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
52845 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
52846 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
52847 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
52848 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
52849 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
52850 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
52851 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
52852 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
52853 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52854 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
52855 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
52856 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
52857 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
52858 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
52859 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
52860 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
52861 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
52863 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
52864 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
52865 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
52866 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
52867 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
52868 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
52869 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
52870 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
52871 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
52872 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
52873 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
52874 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
52875 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
52876 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
52877 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
52878 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
52879 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
52880 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
52881 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
52882 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
52883 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
52884 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
52885 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
52886 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
52887 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
52888 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
52889 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
52890 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
52891 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
52892 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
52893 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
52894 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
52895 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
52896 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
52897 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
52898 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
52899 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52900 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
52901 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
52902 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52903 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52904 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
52905 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
52906 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
52907 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
52908 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
52909 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
52910 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52911 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
52912 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
52913 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52914 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52915 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
52916 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
52917 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52918 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
52919 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
52920 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52921 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
52922 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
52923 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52924 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
52925 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
52926 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
52927 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52928 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
52929 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
52930 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
52931 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
52932 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52933 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
52934 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
52935 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
52936 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52937 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
52938 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
52939 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
52940 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52941 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
52942 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
52943 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52944 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
52945 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
52946 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
52947 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
52948 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
52949 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52950 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
52951 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
52952 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
52953 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
52954 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
52955 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
52956 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
52957 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
52958 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52959 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
52960 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
52961 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
52962 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
52963 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52964 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
52965 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
52966 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
52967 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52968 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
52969 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
52970 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
52971 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
52972 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
52973 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
52974 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52975 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
52976 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
52977 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
52978 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
52979 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
52980 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
52981 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
52982 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
52983 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
52984 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
52985 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
52986 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
52987 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
52988 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
52989 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
52990 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
52991 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
52992 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
52993 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
52994 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
52995 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
52996 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
52997 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
52998 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52999 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53000 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53001 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53002 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53003 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53004 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53005 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53006 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53007 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53008 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53009 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53010 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53011 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53012 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53013 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53014 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53015 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53016 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53017 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53018 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53019 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53020 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53021 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53022 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53023 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53024 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53025 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53026 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53027 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53028 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53029 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53030 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53031 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53032 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53033 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53034 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53035 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53036 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53037 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53038 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53039 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53040 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53041 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53042 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53043 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53044 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53045 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53046 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53047 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53048 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53049 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53050 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53051 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53052 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53053 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53054 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53055 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53056 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53058 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53059 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53060 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53061 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53062 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53063 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53064 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53065 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53066 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53067 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53068 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53069 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53070 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53071 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53072 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53073 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53075 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53076 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53077 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53078 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53079 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53080 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53081 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53082 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53083 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53084 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53085 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53087 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53088 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53089 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53090 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53091 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53093 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53095 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53096 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53097 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53098 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53099 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53100 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53101 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53102 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53105 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53106 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53107 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53108 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53109 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53110 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53111 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53112 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53113 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53114 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53115 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53116 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53117 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53118 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53119 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53121 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53122 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53123 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53124 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53125 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53126 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53127 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53128 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53129 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53131 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53132 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53133 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53134 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53135 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53136 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53138 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53139 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53140 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53141 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53142 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53143 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53144 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53145 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53146 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53147 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53148 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53149 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53151 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53152 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53153 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53154 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53155 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53156 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53157 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53158 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53159 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53160 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53162 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53163 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53164 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53165 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53166 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53167 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53169 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53171 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53172 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53173 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53175 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53176 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53178 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53179 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53180 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53181 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53182 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53183 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53185 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53186 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53187 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53189 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53190 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53191 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53192 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53193 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53194 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53195 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53196 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53197 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53198 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53199 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53200 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53201 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53202 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53203 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53204 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53205 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53206 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53207 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53208 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53209 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53210 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53211 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53212 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53213 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53214 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53215 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53216 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53217 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53218 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53219 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53220 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53221 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53222 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53223 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53224 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53225 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53226 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53227 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53228 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53229 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53230 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53231 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53232 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53233 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53234 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53235 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53237 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53238 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53239 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53240 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53241 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53242 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53243 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53244 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53245 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53246 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53247 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53248 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53249 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53250 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53252 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53253 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53254 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53255 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53256 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53257 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53258 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53259 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53260 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53261 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53263 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53264 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53265 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53266 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53267 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53268 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53269 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53270 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53271 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53272 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53273 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53274 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53275 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53276 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53277 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53278 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53279 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53280 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53281 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53282 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53284 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53285 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53286 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53287 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53288 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53289 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53290 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53291 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53292 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53293 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53294 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53295 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53296 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53297 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53298 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53299 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53300 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53301 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53302 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53303 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53304 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53306 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53307 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53308 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53309 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53310 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53311 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53312 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53313 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53314 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53315 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53316 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53317 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53319 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53320 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53321 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53322 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53323 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53324 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53325 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53333 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53335 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53336 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53337 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53338 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53339 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53340 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53341 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53342 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53343 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53344 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53349 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53350 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53351 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53352 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53355 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53358 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53360 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53362 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53363 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53365 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53366 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53367 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53368 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53369 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53370 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53371 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53372 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53373 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53374 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53375 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53376 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53379 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53380 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53381 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53382 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53384 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53385 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53386 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53388 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53389 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53390 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53391 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53392 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53393 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53394 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53395 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53396 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53398 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53399 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53400 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53402 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53403 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53404 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53405 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53406 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53410 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53412 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53415 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53416 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53417 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53418 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53419 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53420 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53423 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53424 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53425 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53427 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53431 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53432 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53433 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53435 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53436 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53437 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53438 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53439 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53440 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53441 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53442 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53444 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53445 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53446 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53447 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53448 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53449 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53450 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53451 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53455 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53457 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53458 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53462 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53464 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53466 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53467 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53468 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53471 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53472 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53474 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53475 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53476 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53477 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53479 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53480 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53481 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53483 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53484 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53487 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53488 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53490 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53491 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53493 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53496 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53497 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53499 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53501 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53502 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53503 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53504 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53506 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53507 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53510 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53512 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53513 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53514 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53515 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53516 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53519 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53521 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53522 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53523 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53524 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53525 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53526 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53527 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53529 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53531 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53532 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53534 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53535 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53536 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53539 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53540 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53541 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53542 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53543 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53544 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53546 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53548 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53550 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53551 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53552 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53553 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53554 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53555 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53556 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53557 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53558 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53560 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53561 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53562 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53563 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53564 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53565 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53566 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53567 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53568 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53570 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53572 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53573 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53574 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53575 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53576 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53578 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53579 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53580 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53581 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53582 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53583 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53585 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53587 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53590 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53591 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53592 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53593 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53594 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53595 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53596 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53599 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53600 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53601 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53608 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53610 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53611 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53612 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53613 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53614 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53615 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53617 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53618 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53619 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53620 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53621 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53622 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53623 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53626 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53627 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53629 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53630 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53632 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53633 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53634 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53635 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53636 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53637 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53638 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53639 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53644 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53645 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53646 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53647 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53648 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53649 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53650 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53652 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53654 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53657 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53659 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53660 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53661 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53662 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53663 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53664 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53666 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53667 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53670 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53671 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53672 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53673 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53674 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53675 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53676 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53678 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53679 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53680 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53684 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53686 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53687 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53688 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53690 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53691 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53692 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53695 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53697 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53698 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53699 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53700 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53701 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53702 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53704 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53705 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53706 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53707 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53712 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53713 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53715 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53716 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53717 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53721 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53723 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53724 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53725 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53726 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53727 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53729 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53730 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53732 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53733 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53742 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53743 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53744 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53745 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53748 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53750 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53751 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53752 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53753 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53754 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53755 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
53760 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
53761 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
53762 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
53763 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
53764 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
53765 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
53766 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
53767 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
53768 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
53769 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
53770 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
53772 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
53773 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
53774 { NULL, NULL, 0, NULL }
53775 };
53776
53777
53778 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
53779
53780 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
53781 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
53782 }
53783 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
53784 return (void *)((wxSizer *) ((wxBoxSizer *) x));
53785 }
53786 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
53787 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
53788 }
53789 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
53790 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53791 }
53792 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
53793 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53794 }
53795 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
53796 return (void *)((wxSizer *) ((wxGridSizer *) x));
53797 }
53798 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
53799 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
53800 }
53801 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
53802 return (void *)((wxSizer *) ((wxPySizer *) x));
53803 }
53804 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
53805 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
53806 }
53807 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
53808 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53809 }
53810 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
53811 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
53812 }
53813 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
53814 return (void *)((wxEvent *) ((wxMenuEvent *) x));
53815 }
53816 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
53817 return (void *)((wxEvent *) ((wxCloseEvent *) x));
53818 }
53819 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
53820 return (void *)((wxEvent *) ((wxMouseEvent *) x));
53821 }
53822 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
53823 return (void *)((wxEvent *) ((wxEraseEvent *) x));
53824 }
53825 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
53826 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
53827 }
53828 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
53829 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
53830 }
53831 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
53832 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
53833 }
53834 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
53835 return (void *)((wxEvent *) ((wxPyEvent *) x));
53836 }
53837 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
53838 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
53839 }
53840 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
53841 return (void *)((wxEvent *) ((wxIdleEvent *) x));
53842 }
53843 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
53844 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
53845 }
53846 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
53847 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
53848 }
53849 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
53850 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
53851 }
53852 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
53853 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
53854 }
53855 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
53856 return (void *)((wxEvent *) ((wxActivateEvent *) x));
53857 }
53858 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
53859 return (void *)((wxEvent *) ((wxSizeEvent *) x));
53860 }
53861 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
53862 return (void *)((wxEvent *) ((wxMoveEvent *) x));
53863 }
53864 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
53865 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
53866 }
53867 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
53868 return (void *)((wxEvent *) ((wxPaintEvent *) x));
53869 }
53870 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
53871 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
53872 }
53873 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
53874 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
53875 }
53876 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
53877 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
53878 }
53879 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
53880 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
53881 }
53882 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
53883 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
53884 }
53885 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
53886 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
53887 }
53888 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
53889 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
53890 }
53891 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
53892 return (void *)((wxEvent *) ((wxFocusEvent *) x));
53893 }
53894 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
53895 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
53896 }
53897 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
53898 return (void *)((wxEvent *) ((wxShowEvent *) x));
53899 }
53900 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
53901 return (void *)((wxEvent *) ((wxCommandEvent *) x));
53902 }
53903 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
53904 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
53905 }
53906 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
53907 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
53908 }
53909 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
53910 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
53911 }
53912 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
53913 return (void *)((wxEvent *) ((wxKeyEvent *) x));
53914 }
53915 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
53916 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
53917 }
53918 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
53919 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
53920 }
53921 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
53922 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
53923 }
53924 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
53925 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
53926 }
53927 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
53928 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
53929 }
53930 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
53931 return (void *)((wxControl *) ((wxControlWithItems *) x));
53932 }
53933 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
53934 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
53935 }
53936 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
53937 return (void *)((wxEvtHandler *) ((wxWindow *) x));
53938 }
53939 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
53940 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
53941 }
53942 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
53943 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
53944 }
53945 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
53946 return (void *)((wxEvtHandler *) ((wxValidator *) x));
53947 }
53948 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
53949 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
53950 }
53951 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
53952 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
53953 }
53954 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
53955 return (void *)((wxEvtHandler *) ((wxMenu *) x));
53956 }
53957 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
53958 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
53959 }
53960 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
53961 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
53962 }
53963 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
53964 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
53965 }
53966 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
53967 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
53968 }
53969 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
53970 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
53971 }
53972 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
53973 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
53974 }
53975 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
53976 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
53977 }
53978 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
53979 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
53980 }
53981 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
53982 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
53983 }
53984 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
53985 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
53986 }
53987 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
53988 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
53989 }
53990 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
53991 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
53992 }
53993 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
53994 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
53995 }
53996 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
53997 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
53998 }
53999 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54000 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54001 }
54002 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54003 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54004 }
54005 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54006 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54007 }
54008 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54009 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54010 }
54011 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54012 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54013 }
54014 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54015 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54016 }
54017 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54018 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54019 }
54020 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54021 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54022 }
54023 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54024 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54025 }
54026 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54027 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54028 }
54029 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54030 return (void *)((wxObject *) ((wxSizerItem *) x));
54031 }
54032 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54033 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54034 }
54035 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54036 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54037 }
54038 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54039 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54040 }
54041 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54042 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54043 }
54044 static void *_p_wxSizerTo_p_wxObject(void *x) {
54045 return (void *)((wxObject *) ((wxSizer *) x));
54046 }
54047 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54048 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54049 }
54050 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54051 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54052 }
54053 static void *_p_wxEventTo_p_wxObject(void *x) {
54054 return (void *)((wxObject *) ((wxEvent *) x));
54055 }
54056 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54057 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54058 }
54059 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54060 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54061 }
54062 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54063 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54064 }
54065 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54066 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54067 }
54068 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54069 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54070 }
54071 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54072 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54073 }
54074 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54075 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54076 }
54077 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54078 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54079 }
54080 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54081 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54082 }
54083 static void *_p_wxControlTo_p_wxObject(void *x) {
54084 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54085 }
54086 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54087 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54088 }
54089 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54090 return (void *)((wxObject *) ((wxFSFile *) x));
54091 }
54092 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54093 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54094 }
54095 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54096 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54097 }
54098 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54099 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54100 }
54101 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54102 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54103 }
54104 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54105 return (void *)((wxObject *) ((wxMenuItem *) x));
54106 }
54107 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54108 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54109 }
54110 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54111 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54112 }
54113 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54114 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54115 }
54116 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54117 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54118 }
54119 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54120 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54121 }
54122 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54123 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54124 }
54125 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54126 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54127 }
54128 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54129 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54130 }
54131 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54132 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54133 }
54134 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54135 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54136 }
54137 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54138 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54139 }
54140 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54141 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54142 }
54143 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54144 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54145 }
54146 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54147 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54148 }
54149 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54150 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54151 }
54152 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54153 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54154 }
54155 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54156 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54157 }
54158 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54159 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54160 }
54161 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54162 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54163 }
54164 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54165 return (void *)((wxObject *) ((wxImageHandler *) x));
54166 }
54167 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54168 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54169 }
54170 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54171 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54172 }
54173 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54174 return (void *)((wxObject *) ((wxEvtHandler *) x));
54175 }
54176 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54177 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54178 }
54179 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54180 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54181 }
54182 static void *_p_wxImageTo_p_wxObject(void *x) {
54183 return (void *)((wxObject *) ((wxImage *) x));
54184 }
54185 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54186 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54187 }
54188 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54189 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54190 }
54191 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54192 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54193 }
54194 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54195 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54196 }
54197 static void *_p_wxWindowTo_p_wxObject(void *x) {
54198 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54199 }
54200 static void *_p_wxMenuTo_p_wxObject(void *x) {
54201 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54202 }
54203 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54204 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54205 }
54206 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54207 return (void *)((wxObject *) ((wxFileSystem *) x));
54208 }
54209 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54210 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54211 }
54212 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54213 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54214 }
54215 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54216 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54217 }
54218 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54219 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54220 }
54221 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54222 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54223 }
54224 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54225 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54226 }
54227 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54228 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54229 }
54230 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54231 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54232 }
54233 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54234 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54235 }
54236 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54237 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54238 }
54239 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54240 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54241 }
54242 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54243 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54244 }
54245 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54246 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54247 }
54248 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54249 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54250 }
54251 static void *_p_wxControlTo_p_wxWindow(void *x) {
54252 return (void *)((wxWindow *) ((wxControl *) x));
54253 }
54254 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54255 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54256 }
54257 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54258 return (void *)((wxWindow *) ((wxMenuBar *) x));
54259 }
54260 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54261 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54262 }
54263 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54264 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54265 }
54266 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54267 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54268 }
54269 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54270 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54271 }
54272 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54273 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54274 }
54275 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54276 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54277 }
54278 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54279 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54280 }
54281 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54282 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54283 }
54284 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54285 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54286 }
54287 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54288 return (void *)((wxValidator *) ((wxPyValidator *) x));
54289 }
54290 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54291 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54292 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};
54293 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54294 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54295 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54296 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54297 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54298 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54299 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54300 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54301 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54302 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54303 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54304 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54305 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54306 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54307 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54308 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54309 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54310 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54311 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54312 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54313 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54314 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54315 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54316 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54317 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54318 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54319 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54320 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54321 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54322 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54323 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54324 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54325 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54326 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54327 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54328 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54329 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54330 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54331 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54332 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54333 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54334 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54335 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54336 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54337 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54338 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54339 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54340 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54341 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54342 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54343 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54344 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54345 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54346 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54347 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54348 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54349 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54350 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54351 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54352 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54353 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54354 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54355 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54356 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54357 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54358 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54359 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54360 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54361 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54362 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54363 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54364 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54365 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54366 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54367 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54368 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54369 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54370 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54371 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54372 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54373 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54374 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54375 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54376 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54377 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54378 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54379 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54380 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54381 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54382 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54383 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54384 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54385 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54386 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54387 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54388 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54389 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54390 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54391 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54392 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54393 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54394 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54395 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54396 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54397 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54398 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54399 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54400 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54401 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54402 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54403 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54404 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54405 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54406 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54407 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54408 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54409 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54410 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54411 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54412 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54413 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54414 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54415 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54416 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54417 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54418 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54419
54420 static swig_type_info *swig_type_initial[] = {
54421 &_swigt__p_buffer,
54422 &_swigt__p_char,
54423 &_swigt__p_form_ops_t,
54424 &_swigt__p_int,
54425 &_swigt__p_long,
54426 &_swigt__p_unsigned_char,
54427 &_swigt__p_unsigned_int,
54428 &_swigt__p_unsigned_long,
54429 &_swigt__p_wxANIHandler,
54430 &_swigt__p_wxAcceleratorEntry,
54431 &_swigt__p_wxAcceleratorTable,
54432 &_swigt__p_wxActivateEvent,
54433 &_swigt__p_wxAppTraits,
54434 &_swigt__p_wxArrayString,
54435 &_swigt__p_wxBMPHandler,
54436 &_swigt__p_wxBitmap,
54437 &_swigt__p_wxBoxSizer,
54438 &_swigt__p_wxButton,
54439 &_swigt__p_wxCURHandler,
54440 &_swigt__p_wxCaret,
54441 &_swigt__p_wxChildFocusEvent,
54442 &_swigt__p_wxCloseEvent,
54443 &_swigt__p_wxColour,
54444 &_swigt__p_wxCommandEvent,
54445 &_swigt__p_wxContextMenuEvent,
54446 &_swigt__p_wxControl,
54447 &_swigt__p_wxControlWithItems,
54448 &_swigt__p_wxCursor,
54449 &_swigt__p_wxDC,
54450 &_swigt__p_wxDateEvent,
54451 &_swigt__p_wxDateTime,
54452 &_swigt__p_wxDisplayChangedEvent,
54453 &_swigt__p_wxDropFilesEvent,
54454 &_swigt__p_wxDuplexMode,
54455 &_swigt__p_wxEraseEvent,
54456 &_swigt__p_wxEvent,
54457 &_swigt__p_wxEventLoop,
54458 &_swigt__p_wxEventLoopActivator,
54459 &_swigt__p_wxEvtHandler,
54460 &_swigt__p_wxFSFile,
54461 &_swigt__p_wxFileSystem,
54462 &_swigt__p_wxFileSystemHandler,
54463 &_swigt__p_wxFlexGridSizer,
54464 &_swigt__p_wxFocusEvent,
54465 &_swigt__p_wxFont,
54466 &_swigt__p_wxFrame,
54467 &_swigt__p_wxGBPosition,
54468 &_swigt__p_wxGBSizerItem,
54469 &_swigt__p_wxGBSpan,
54470 &_swigt__p_wxGIFHandler,
54471 &_swigt__p_wxGridBagSizer,
54472 &_swigt__p_wxGridSizer,
54473 &_swigt__p_wxICOHandler,
54474 &_swigt__p_wxIconizeEvent,
54475 &_swigt__p_wxIdleEvent,
54476 &_swigt__p_wxImage,
54477 &_swigt__p_wxImageHandler,
54478 &_swigt__p_wxImageHistogram,
54479 &_swigt__p_wxImage_HSVValue,
54480 &_swigt__p_wxImage_RGBValue,
54481 &_swigt__p_wxIndividualLayoutConstraint,
54482 &_swigt__p_wxInitDialogEvent,
54483 &_swigt__p_wxInputStream,
54484 &_swigt__p_wxInternetFSHandler,
54485 &_swigt__p_wxItemContainer,
54486 &_swigt__p_wxJPEGHandler,
54487 &_swigt__p_wxKeyEvent,
54488 &_swigt__p_wxLayoutConstraints,
54489 &_swigt__p_wxMaximizeEvent,
54490 &_swigt__p_wxMemoryFSHandler,
54491 &_swigt__p_wxMenu,
54492 &_swigt__p_wxMenuBar,
54493 &_swigt__p_wxMenuBarBase,
54494 &_swigt__p_wxMenuEvent,
54495 &_swigt__p_wxMenuItem,
54496 &_swigt__p_wxMouseCaptureChangedEvent,
54497 &_swigt__p_wxMouseEvent,
54498 &_swigt__p_wxMoveEvent,
54499 &_swigt__p_wxNavigationKeyEvent,
54500 &_swigt__p_wxNcPaintEvent,
54501 &_swigt__p_wxNotifyEvent,
54502 &_swigt__p_wxObject,
54503 &_swigt__p_wxOutputStream,
54504 &_swigt__p_wxPCXHandler,
54505 &_swigt__p_wxPNGHandler,
54506 &_swigt__p_wxPNMHandler,
54507 &_swigt__p_wxPaintEvent,
54508 &_swigt__p_wxPaletteChangedEvent,
54509 &_swigt__p_wxPaperSize,
54510 &_swigt__p_wxPoint,
54511 &_swigt__p_wxPoint2D,
54512 &_swigt__p_wxPropagateOnce,
54513 &_swigt__p_wxPropagationDisabler,
54514 &_swigt__p_wxPyApp,
54515 &_swigt__p_wxPyCommandEvent,
54516 &_swigt__p_wxPyDropTarget,
54517 &_swigt__p_wxPyEvent,
54518 &_swigt__p_wxPyFileSystemHandler,
54519 &_swigt__p_wxPyImageHandler,
54520 &_swigt__p_wxPyInputStream,
54521 &_swigt__p_wxPySizer,
54522 &_swigt__p_wxPyValidator,
54523 &_swigt__p_wxQuantize,
54524 &_swigt__p_wxQueryNewPaletteEvent,
54525 &_swigt__p_wxRealPoint,
54526 &_swigt__p_wxRect,
54527 &_swigt__p_wxRegion,
54528 &_swigt__p_wxScrollEvent,
54529 &_swigt__p_wxScrollWinEvent,
54530 &_swigt__p_wxSetCursorEvent,
54531 &_swigt__p_wxShowEvent,
54532 &_swigt__p_wxSize,
54533 &_swigt__p_wxSizeEvent,
54534 &_swigt__p_wxSizer,
54535 &_swigt__p_wxSizerItem,
54536 &_swigt__p_wxStaticBox,
54537 &_swigt__p_wxStaticBoxSizer,
54538 &_swigt__p_wxStdDialogButtonSizer,
54539 &_swigt__p_wxSysColourChangedEvent,
54540 &_swigt__p_wxTIFFHandler,
54541 &_swigt__p_wxToolTip,
54542 &_swigt__p_wxUpdateUIEvent,
54543 &_swigt__p_wxValidator,
54544 &_swigt__p_wxVisualAttributes,
54545 &_swigt__p_wxWindow,
54546 &_swigt__p_wxWindowCreateEvent,
54547 &_swigt__p_wxWindowDestroyEvent,
54548 &_swigt__p_wxXPMHandler,
54549 &_swigt__p_wxZipFSHandler,
54550 };
54551
54552 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54553 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54554 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54555 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54556 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54557 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54558 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54559 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54560 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54561 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54562 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54563 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54564 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54565 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54566 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}};
54567 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54568 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}};
54569 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54570 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}};
54571 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54572 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54573 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54574 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54575 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
54576 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54577 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}};
54578 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54579 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54580 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54581 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54582 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54583 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54584 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54585 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54586 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54587 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
54588 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54589 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54590 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}};
54591 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54592 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54593 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}};
54594 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}};
54595 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54596 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54597 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54598 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54599 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54600 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54601 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54602 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54603 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}};
54604 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}};
54605 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54606 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54607 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54608 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}};
54609 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54610 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54611 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54612 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54613 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54614 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54615 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54616 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}};
54617 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54618 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54619 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54620 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54621 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54622 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54623 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54624 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54625 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54626 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54627 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54628 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54629 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54630 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54631 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54632 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54633 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
54634 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54635 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54636 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54637 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54638 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54639 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54640 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54641 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54642 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54643 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54644 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54645 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54646 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54647 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54648 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54649 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54650 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54651 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54652 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54653 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54654 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54655 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54656 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54657 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54658 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54659 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54660 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54661 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54662 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54663 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54664 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54665 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}};
54666 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}};
54667 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54668 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54669 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54670 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54671 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54672 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54673 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54674 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}};
54675 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54676 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}};
54677 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54678 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54679 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54680 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54681
54682 static swig_cast_info *swig_cast_initial[] = {
54683 _swigc__p_buffer,
54684 _swigc__p_char,
54685 _swigc__p_form_ops_t,
54686 _swigc__p_int,
54687 _swigc__p_long,
54688 _swigc__p_unsigned_char,
54689 _swigc__p_unsigned_int,
54690 _swigc__p_unsigned_long,
54691 _swigc__p_wxANIHandler,
54692 _swigc__p_wxAcceleratorEntry,
54693 _swigc__p_wxAcceleratorTable,
54694 _swigc__p_wxActivateEvent,
54695 _swigc__p_wxAppTraits,
54696 _swigc__p_wxArrayString,
54697 _swigc__p_wxBMPHandler,
54698 _swigc__p_wxBitmap,
54699 _swigc__p_wxBoxSizer,
54700 _swigc__p_wxButton,
54701 _swigc__p_wxCURHandler,
54702 _swigc__p_wxCaret,
54703 _swigc__p_wxChildFocusEvent,
54704 _swigc__p_wxCloseEvent,
54705 _swigc__p_wxColour,
54706 _swigc__p_wxCommandEvent,
54707 _swigc__p_wxContextMenuEvent,
54708 _swigc__p_wxControl,
54709 _swigc__p_wxControlWithItems,
54710 _swigc__p_wxCursor,
54711 _swigc__p_wxDC,
54712 _swigc__p_wxDateEvent,
54713 _swigc__p_wxDateTime,
54714 _swigc__p_wxDisplayChangedEvent,
54715 _swigc__p_wxDropFilesEvent,
54716 _swigc__p_wxDuplexMode,
54717 _swigc__p_wxEraseEvent,
54718 _swigc__p_wxEvent,
54719 _swigc__p_wxEventLoop,
54720 _swigc__p_wxEventLoopActivator,
54721 _swigc__p_wxEvtHandler,
54722 _swigc__p_wxFSFile,
54723 _swigc__p_wxFileSystem,
54724 _swigc__p_wxFileSystemHandler,
54725 _swigc__p_wxFlexGridSizer,
54726 _swigc__p_wxFocusEvent,
54727 _swigc__p_wxFont,
54728 _swigc__p_wxFrame,
54729 _swigc__p_wxGBPosition,
54730 _swigc__p_wxGBSizerItem,
54731 _swigc__p_wxGBSpan,
54732 _swigc__p_wxGIFHandler,
54733 _swigc__p_wxGridBagSizer,
54734 _swigc__p_wxGridSizer,
54735 _swigc__p_wxICOHandler,
54736 _swigc__p_wxIconizeEvent,
54737 _swigc__p_wxIdleEvent,
54738 _swigc__p_wxImage,
54739 _swigc__p_wxImageHandler,
54740 _swigc__p_wxImageHistogram,
54741 _swigc__p_wxImage_HSVValue,
54742 _swigc__p_wxImage_RGBValue,
54743 _swigc__p_wxIndividualLayoutConstraint,
54744 _swigc__p_wxInitDialogEvent,
54745 _swigc__p_wxInputStream,
54746 _swigc__p_wxInternetFSHandler,
54747 _swigc__p_wxItemContainer,
54748 _swigc__p_wxJPEGHandler,
54749 _swigc__p_wxKeyEvent,
54750 _swigc__p_wxLayoutConstraints,
54751 _swigc__p_wxMaximizeEvent,
54752 _swigc__p_wxMemoryFSHandler,
54753 _swigc__p_wxMenu,
54754 _swigc__p_wxMenuBar,
54755 _swigc__p_wxMenuBarBase,
54756 _swigc__p_wxMenuEvent,
54757 _swigc__p_wxMenuItem,
54758 _swigc__p_wxMouseCaptureChangedEvent,
54759 _swigc__p_wxMouseEvent,
54760 _swigc__p_wxMoveEvent,
54761 _swigc__p_wxNavigationKeyEvent,
54762 _swigc__p_wxNcPaintEvent,
54763 _swigc__p_wxNotifyEvent,
54764 _swigc__p_wxObject,
54765 _swigc__p_wxOutputStream,
54766 _swigc__p_wxPCXHandler,
54767 _swigc__p_wxPNGHandler,
54768 _swigc__p_wxPNMHandler,
54769 _swigc__p_wxPaintEvent,
54770 _swigc__p_wxPaletteChangedEvent,
54771 _swigc__p_wxPaperSize,
54772 _swigc__p_wxPoint,
54773 _swigc__p_wxPoint2D,
54774 _swigc__p_wxPropagateOnce,
54775 _swigc__p_wxPropagationDisabler,
54776 _swigc__p_wxPyApp,
54777 _swigc__p_wxPyCommandEvent,
54778 _swigc__p_wxPyDropTarget,
54779 _swigc__p_wxPyEvent,
54780 _swigc__p_wxPyFileSystemHandler,
54781 _swigc__p_wxPyImageHandler,
54782 _swigc__p_wxPyInputStream,
54783 _swigc__p_wxPySizer,
54784 _swigc__p_wxPyValidator,
54785 _swigc__p_wxQuantize,
54786 _swigc__p_wxQueryNewPaletteEvent,
54787 _swigc__p_wxRealPoint,
54788 _swigc__p_wxRect,
54789 _swigc__p_wxRegion,
54790 _swigc__p_wxScrollEvent,
54791 _swigc__p_wxScrollWinEvent,
54792 _swigc__p_wxSetCursorEvent,
54793 _swigc__p_wxShowEvent,
54794 _swigc__p_wxSize,
54795 _swigc__p_wxSizeEvent,
54796 _swigc__p_wxSizer,
54797 _swigc__p_wxSizerItem,
54798 _swigc__p_wxStaticBox,
54799 _swigc__p_wxStaticBoxSizer,
54800 _swigc__p_wxStdDialogButtonSizer,
54801 _swigc__p_wxSysColourChangedEvent,
54802 _swigc__p_wxTIFFHandler,
54803 _swigc__p_wxToolTip,
54804 _swigc__p_wxUpdateUIEvent,
54805 _swigc__p_wxValidator,
54806 _swigc__p_wxVisualAttributes,
54807 _swigc__p_wxWindow,
54808 _swigc__p_wxWindowCreateEvent,
54809 _swigc__p_wxWindowDestroyEvent,
54810 _swigc__p_wxXPMHandler,
54811 _swigc__p_wxZipFSHandler,
54812 };
54813
54814
54815 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
54816
54817 static swig_const_info swig_const_table[] = {
54818 {0, 0, 0, 0.0, 0, 0}};
54819
54820 #ifdef __cplusplus
54821 }
54822 #endif
54823 /* -----------------------------------------------------------------------------
54824 * Type initialization:
54825 * This problem is tough by the requirement that no dynamic
54826 * memory is used. Also, since swig_type_info structures store pointers to
54827 * swig_cast_info structures and swig_cast_info structures store pointers back
54828 * to swig_type_info structures, we need some lookup code at initialization.
54829 * The idea is that swig generates all the structures that are needed.
54830 * The runtime then collects these partially filled structures.
54831 * The SWIG_InitializeModule function takes these initial arrays out of
54832 * swig_module, and does all the lookup, filling in the swig_module.types
54833 * array with the correct data and linking the correct swig_cast_info
54834 * structures together.
54835 *
54836 * The generated swig_type_info structures are assigned staticly to an initial
54837 * array. We just loop though that array, and handle each type individually.
54838 * First we lookup if this type has been already loaded, and if so, use the
54839 * loaded structure instead of the generated one. Then we have to fill in the
54840 * cast linked list. The cast data is initially stored in something like a
54841 * two-dimensional array. Each row corresponds to a type (there are the same
54842 * number of rows as there are in the swig_type_initial array). Each entry in
54843 * a column is one of the swig_cast_info structures for that type.
54844 * The cast_initial array is actually an array of arrays, because each row has
54845 * a variable number of columns. So to actually build the cast linked list,
54846 * we find the array of casts associated with the type, and loop through it
54847 * adding the casts to the list. The one last trick we need to do is making
54848 * sure the type pointer in the swig_cast_info struct is correct.
54849 *
54850 * First off, we lookup the cast->type name to see if it is already loaded.
54851 * There are three cases to handle:
54852 * 1) If the cast->type has already been loaded AND the type we are adding
54853 * casting info to has not been loaded (it is in this module), THEN we
54854 * replace the cast->type pointer with the type pointer that has already
54855 * been loaded.
54856 * 2) If BOTH types (the one we are adding casting info to, and the
54857 * cast->type) are loaded, THEN the cast info has already been loaded by
54858 * the previous module so we just ignore it.
54859 * 3) Finally, if cast->type has not already been loaded, then we add that
54860 * swig_cast_info to the linked list (because the cast->type) pointer will
54861 * be correct.
54862 * ----------------------------------------------------------------------------- */
54863
54864 #ifdef __cplusplus
54865 extern "C" {
54866 #if 0
54867 } /* c-mode */
54868 #endif
54869 #endif
54870
54871 #if 0
54872 #define SWIGRUNTIME_DEBUG
54873 #endif
54874
54875 SWIGRUNTIME void
54876 SWIG_InitializeModule(void *clientdata) {
54877 size_t i;
54878 swig_module_info *module_head;
54879 static int init_run = 0;
54880
54881 clientdata = clientdata;
54882
54883 if (init_run) return;
54884 init_run = 1;
54885
54886 /* Initialize the swig_module */
54887 swig_module.type_initial = swig_type_initial;
54888 swig_module.cast_initial = swig_cast_initial;
54889
54890 /* Try and load any already created modules */
54891 module_head = SWIG_GetModule(clientdata);
54892 if (module_head) {
54893 swig_module.next = module_head->next;
54894 module_head->next = &swig_module;
54895 } else {
54896 /* This is the first module loaded */
54897 swig_module.next = &swig_module;
54898 SWIG_SetModule(clientdata, &swig_module);
54899 }
54900
54901 /* Now work on filling in swig_module.types */
54902 #ifdef SWIGRUNTIME_DEBUG
54903 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
54904 #endif
54905 for (i = 0; i < swig_module.size; ++i) {
54906 swig_type_info *type = 0;
54907 swig_type_info *ret;
54908 swig_cast_info *cast;
54909
54910 #ifdef SWIGRUNTIME_DEBUG
54911 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
54912 #endif
54913
54914 /* if there is another module already loaded */
54915 if (swig_module.next != &swig_module) {
54916 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
54917 }
54918 if (type) {
54919 /* Overwrite clientdata field */
54920 #ifdef SWIGRUNTIME_DEBUG
54921 printf("SWIG_InitializeModule: found type %s\n", type->name);
54922 #endif
54923 if (swig_module.type_initial[i]->clientdata) {
54924 type->clientdata = swig_module.type_initial[i]->clientdata;
54925 #ifdef SWIGRUNTIME_DEBUG
54926 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
54927 #endif
54928 }
54929 } else {
54930 type = swig_module.type_initial[i];
54931 }
54932
54933 /* Insert casting types */
54934 cast = swig_module.cast_initial[i];
54935 while (cast->type) {
54936 /* Don't need to add information already in the list */
54937 ret = 0;
54938 #ifdef SWIGRUNTIME_DEBUG
54939 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
54940 #endif
54941 if (swig_module.next != &swig_module) {
54942 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
54943 #ifdef SWIGRUNTIME_DEBUG
54944 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
54945 #endif
54946 }
54947 if (ret) {
54948 if (type == swig_module.type_initial[i]) {
54949 #ifdef SWIGRUNTIME_DEBUG
54950 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
54951 #endif
54952 cast->type = ret;
54953 ret = 0;
54954 } else {
54955 /* Check for casting already in the list */
54956 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
54957 #ifdef SWIGRUNTIME_DEBUG
54958 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
54959 #endif
54960 if (!ocast) ret = 0;
54961 }
54962 }
54963
54964 if (!ret) {
54965 #ifdef SWIGRUNTIME_DEBUG
54966 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
54967 #endif
54968 if (type->cast) {
54969 type->cast->prev = cast;
54970 cast->next = type->cast;
54971 }
54972 type->cast = cast;
54973 }
54974 cast++;
54975 }
54976 /* Set entry in modules->types array equal to the type */
54977 swig_module.types[i] = type;
54978 }
54979 swig_module.types[i] = 0;
54980
54981 #ifdef SWIGRUNTIME_DEBUG
54982 printf("**** SWIG_InitializeModule: Cast List ******\n");
54983 for (i = 0; i < swig_module.size; ++i) {
54984 int j = 0;
54985 swig_cast_info *cast = swig_module.cast_initial[i];
54986 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
54987 while (cast->type) {
54988 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
54989 cast++;
54990 ++j;
54991 }
54992 printf("---- Total casts: %d\n",j);
54993 }
54994 printf("**** SWIG_InitializeModule: Cast List ******\n");
54995 #endif
54996 }
54997
54998 /* This function will propagate the clientdata field of type to
54999 * any new swig_type_info structures that have been added into the list
55000 * of equivalent types. It is like calling
55001 * SWIG_TypeClientData(type, clientdata) a second time.
55002 */
55003 SWIGRUNTIME void
55004 SWIG_PropagateClientData(void) {
55005 size_t i;
55006 swig_cast_info *equiv;
55007 static int init_run = 0;
55008
55009 if (init_run) return;
55010 init_run = 1;
55011
55012 for (i = 0; i < swig_module.size; i++) {
55013 if (swig_module.types[i]->clientdata) {
55014 equiv = swig_module.types[i]->cast;
55015 while (equiv) {
55016 if (!equiv->converter) {
55017 if (equiv->type && !equiv->type->clientdata)
55018 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55019 }
55020 equiv = equiv->next;
55021 }
55022 }
55023 }
55024 }
55025
55026 #ifdef __cplusplus
55027 #if 0
55028 {
55029 /* c-mode */
55030 #endif
55031 }
55032 #endif
55033
55034
55035
55036 #ifdef __cplusplus
55037 extern "C" {
55038 #endif
55039
55040 /* Python-specific SWIG API */
55041 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55042 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55043 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55044
55045 /* -----------------------------------------------------------------------------
55046 * global variable support code.
55047 * ----------------------------------------------------------------------------- */
55048
55049 typedef struct swig_globalvar {
55050 char *name; /* Name of global variable */
55051 PyObject *(*get_attr)(void); /* Return the current value */
55052 int (*set_attr)(PyObject *); /* Set the value */
55053 struct swig_globalvar *next;
55054 } swig_globalvar;
55055
55056 typedef struct swig_varlinkobject {
55057 PyObject_HEAD
55058 swig_globalvar *vars;
55059 } swig_varlinkobject;
55060
55061 SWIGINTERN PyObject *
55062 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55063 return PyString_FromString("<Swig global variables>");
55064 }
55065
55066 SWIGINTERN PyObject *
55067 swig_varlink_str(swig_varlinkobject *v) {
55068 PyObject *str = PyString_FromString("(");
55069 swig_globalvar *var;
55070 for (var = v->vars; var; var=var->next) {
55071 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55072 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55073 }
55074 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55075 return str;
55076 }
55077
55078 SWIGINTERN int
55079 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55080 PyObject *str = swig_varlink_str(v);
55081 fprintf(fp,"Swig global variables ");
55082 fprintf(fp,"%s\n", PyString_AsString(str));
55083 Py_DECREF(str);
55084 return 0;
55085 }
55086
55087 SWIGINTERN void
55088 swig_varlink_dealloc(swig_varlinkobject *v) {
55089 swig_globalvar *var = v->vars;
55090 while (var) {
55091 swig_globalvar *n = var->next;
55092 free(var->name);
55093 free(var);
55094 var = n;
55095 }
55096 }
55097
55098 SWIGINTERN PyObject *
55099 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55100 PyObject *res = NULL;
55101 swig_globalvar *var = v->vars;
55102 while (var) {
55103 if (strcmp(var->name,n) == 0) {
55104 res = (*var->get_attr)();
55105 break;
55106 }
55107 var = var->next;
55108 }
55109 if (res == NULL && !PyErr_Occurred()) {
55110 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55111 }
55112 return res;
55113 }
55114
55115 SWIGINTERN int
55116 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55117 int res = 1;
55118 swig_globalvar *var = v->vars;
55119 while (var) {
55120 if (strcmp(var->name,n) == 0) {
55121 res = (*var->set_attr)(p);
55122 break;
55123 }
55124 var = var->next;
55125 }
55126 if (res == 1 && !PyErr_Occurred()) {
55127 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55128 }
55129 return res;
55130 }
55131
55132 SWIGINTERN PyTypeObject*
55133 swig_varlink_type(void) {
55134 static char varlink__doc__[] = "Swig var link object";
55135 static PyTypeObject varlink_type;
55136 static int type_init = 0;
55137 if (!type_init) {
55138 const PyTypeObject tmp
55139 = {
55140 PyObject_HEAD_INIT(NULL)
55141 0, /* Number of items in variable part (ob_size) */
55142 (char *)"swigvarlink", /* Type name (tp_name) */
55143 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55144 0, /* Itemsize (tp_itemsize) */
55145 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55146 (printfunc) swig_varlink_print, /* Print (tp_print) */
55147 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55148 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55149 0, /* tp_compare */
55150 (reprfunc) swig_varlink_repr, /* tp_repr */
55151 0, /* tp_as_number */
55152 0, /* tp_as_sequence */
55153 0, /* tp_as_mapping */
55154 0, /* tp_hash */
55155 0, /* tp_call */
55156 (reprfunc)swig_varlink_str, /* tp_str */
55157 0, /* tp_getattro */
55158 0, /* tp_setattro */
55159 0, /* tp_as_buffer */
55160 0, /* tp_flags */
55161 varlink__doc__, /* tp_doc */
55162 0, /* tp_traverse */
55163 0, /* tp_clear */
55164 0, /* tp_richcompare */
55165 0, /* tp_weaklistoffset */
55166 #if PY_VERSION_HEX >= 0x02020000
55167 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55168 #endif
55169 #if PY_VERSION_HEX >= 0x02030000
55170 0, /* tp_del */
55171 #endif
55172 #ifdef COUNT_ALLOCS
55173 0,0,0,0 /* tp_alloc -> tp_next */
55174 #endif
55175 };
55176 varlink_type = tmp;
55177 varlink_type.ob_type = &PyType_Type;
55178 type_init = 1;
55179 }
55180 return &varlink_type;
55181 }
55182
55183 /* Create a variable linking object for use later */
55184 SWIGINTERN PyObject *
55185 SWIG_Python_newvarlink(void) {
55186 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55187 if (result) {
55188 result->vars = 0;
55189 }
55190 return ((PyObject*) result);
55191 }
55192
55193 SWIGINTERN void
55194 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55195 swig_varlinkobject *v = (swig_varlinkobject *) p;
55196 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55197 if (gv) {
55198 size_t size = strlen(name)+1;
55199 gv->name = (char *)malloc(size);
55200 if (gv->name) {
55201 strncpy(gv->name,name,size);
55202 gv->get_attr = get_attr;
55203 gv->set_attr = set_attr;
55204 gv->next = v->vars;
55205 }
55206 }
55207 v->vars = gv;
55208 }
55209
55210 SWIGINTERN PyObject *
55211 SWIG_globals() {
55212 static PyObject *_SWIG_globals = 0;
55213 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55214 return _SWIG_globals;
55215 }
55216
55217 /* -----------------------------------------------------------------------------
55218 * constants/methods manipulation
55219 * ----------------------------------------------------------------------------- */
55220
55221 /* Install Constants */
55222 SWIGINTERN void
55223 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55224 PyObject *obj = 0;
55225 size_t i;
55226 for (i = 0; constants[i].type; ++i) {
55227 switch(constants[i].type) {
55228 case SWIG_PY_POINTER:
55229 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55230 break;
55231 case SWIG_PY_BINARY:
55232 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55233 break;
55234 default:
55235 obj = 0;
55236 break;
55237 }
55238 if (obj) {
55239 PyDict_SetItemString(d, constants[i].name, obj);
55240 Py_DECREF(obj);
55241 }
55242 }
55243 }
55244
55245 /* -----------------------------------------------------------------------------*/
55246 /* Fix SwigMethods to carry the callback ptrs when needed */
55247 /* -----------------------------------------------------------------------------*/
55248
55249 SWIGINTERN void
55250 SWIG_Python_FixMethods(PyMethodDef *methods,
55251 swig_const_info *const_table,
55252 swig_type_info **types,
55253 swig_type_info **types_initial) {
55254 size_t i;
55255 for (i = 0; methods[i].ml_name; ++i) {
55256 char *c = methods[i].ml_doc;
55257 if (c && (c = strstr(c, "swig_ptr: "))) {
55258 int j;
55259 swig_const_info *ci = 0;
55260 char *name = c + 10;
55261 for (j = 0; const_table[j].type; ++j) {
55262 if (strncmp(const_table[j].name, name,
55263 strlen(const_table[j].name)) == 0) {
55264 ci = &(const_table[j]);
55265 break;
55266 }
55267 }
55268 if (ci) {
55269 size_t shift = (ci->ptype) - types;
55270 swig_type_info *ty = types_initial[shift];
55271 size_t ldoc = (c - methods[i].ml_doc);
55272 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55273 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55274 if (ndoc) {
55275 char *buff = ndoc;
55276 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55277 if (ptr) {
55278 strncpy(buff, methods[i].ml_doc, ldoc);
55279 buff += ldoc;
55280 strncpy(buff, "swig_ptr: ", 10);
55281 buff += 10;
55282 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55283 methods[i].ml_doc = ndoc;
55284 }
55285 }
55286 }
55287 }
55288 }
55289 }
55290
55291 #ifdef __cplusplus
55292 }
55293 #endif
55294
55295 /* -----------------------------------------------------------------------------*
55296 * Partial Init method
55297 * -----------------------------------------------------------------------------*/
55298
55299 #ifdef __cplusplus
55300 extern "C"
55301 #endif
55302 SWIGEXPORT void SWIG_init(void) {
55303 PyObject *m, *d;
55304
55305 /* Fix SwigMethods to carry the callback ptrs when needed */
55306 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55307
55308 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55309 d = PyModule_GetDict(m);
55310
55311 SWIG_InitializeModule(0);
55312 SWIG_InstallConstants(d,swig_const_table);
55313
55314
55315
55316 #ifndef wxPyUSE_EXPORT
55317 // Make our API structure a CObject so other modules can import it
55318 // from this module.
55319 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55320 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55321 Py_XDECREF(cobj);
55322 #endif
55323
55324 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55325 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55326 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55327 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55328 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55329 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55330 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55331 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55332 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55333 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55334 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55335 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55336 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55337 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55338 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55339 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55340 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55341 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55342 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55343 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55344 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55345 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55346 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55347 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55348 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55349 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55350 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55351 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55352 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55353 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55354 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55355 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55356 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55357 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55358 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55359 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55360 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55361 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55362 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55363 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55364 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55365 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55366 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55367 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55368 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55369 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55370 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55371 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55372 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55373 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55374 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55375 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55376 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55377 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55378 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55379 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55380 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55381 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55382 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55383 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55384 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55385 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55386 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55387 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55388 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55389 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55390 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55391 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55392 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55393 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55394 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55395 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55396 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55397 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55398 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55399 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55400 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55401 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55402 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55403 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55404 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55405 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55406 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55407 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55408 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55409 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55410 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55411 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55412 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55413 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55414 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55415 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55416 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55417 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55418 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55419 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55420 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55421 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55422 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55423 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55424 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55425 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55426 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55427 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55428 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55429 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55430 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55431 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55432 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55433 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55434 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55435 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55436 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55437 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55438 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55439 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55440 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55441 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55442 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55443 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55444 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55445 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55446 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55447 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55448 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55449 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55450 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55451 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55452 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55453 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55454 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55455 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55456 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55457 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55458 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55459 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55460 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55461 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55462 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55463 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55464 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55465 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55466 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55467 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55468 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55469 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55470 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55471 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55472 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55473 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55474 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55475 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55476 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55477 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55478 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55479 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55480 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55481 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55482 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55483 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55484 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55485 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55486 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55487 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55488 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55489 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55490 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55491 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55492 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55493 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55494 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55495 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55496 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55497 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55498 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55499 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55500 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55501 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55502 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55503 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55504 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55505 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55506 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55507 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55508 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55509 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55510 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55511 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55512 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55513 SWIG_Python_SetConstant(d, "OPEN",SWIG_From_int(static_cast< int >(wxOPEN)));
55514 SWIG_Python_SetConstant(d, "SAVE",SWIG_From_int(static_cast< int >(wxSAVE)));
55515 SWIG_Python_SetConstant(d, "HIDE_READONLY",SWIG_From_int(static_cast< int >(wxHIDE_READONLY)));
55516 SWIG_Python_SetConstant(d, "OVERWRITE_PROMPT",SWIG_From_int(static_cast< int >(wxOVERWRITE_PROMPT)));
55517 SWIG_Python_SetConstant(d, "FILE_MUST_EXIST",SWIG_From_int(static_cast< int >(wxFILE_MUST_EXIST)));
55518 SWIG_Python_SetConstant(d, "MULTIPLE",SWIG_From_int(static_cast< int >(wxMULTIPLE)));
55519 SWIG_Python_SetConstant(d, "CHANGE_DIR",SWIG_From_int(static_cast< int >(wxCHANGE_DIR)));
55520 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55521 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55522 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55523 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55524 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55525 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55526 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55527 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55528 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55529 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55530 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55531 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55532 SWIG_Python_SetConstant(d, "DD_NEW_DIR_BUTTON",SWIG_From_int(static_cast< int >(wxDD_NEW_DIR_BUTTON)));
55533 SWIG_Python_SetConstant(d, "DD_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxDD_DEFAULT_STYLE)));
55534 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55535 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55536 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55537 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55538 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55539 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55540 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55541 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55542 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55543 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55544 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55545 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55546 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55547 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55548 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55549 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55550 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55551 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55552 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55553 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55554 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55555 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55556 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55557 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55558 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55559 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55560 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55561 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55562 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55563 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55564 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55565 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55566 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55567 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55568 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55569 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55570 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55571 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55572 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55573 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55574 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55575 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55576 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55577 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55578 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55579 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55580 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55581 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55582 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55583 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55584 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55585 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55586 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55587 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55588 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55589 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55590 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55591 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55592 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55593 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55594 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55595 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55596 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55597 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55598 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55599 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55600 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55601 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55602 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55603 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55604 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55605 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55606 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55607 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55608 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55609 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55610 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55611 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55612 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55613 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55614 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55615 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55616 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55617 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55618 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55619 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55620 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55621 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55622 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55623 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55624 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55625 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55626 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55627 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55628 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55629 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55630 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55631 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55632 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55633 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55634 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55635 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55636 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55637 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55638 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55639 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55640 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55641 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55642 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55643 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55644 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55645 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55646 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55647 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55648 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55649 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55650 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55651 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55652 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55653 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55654 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55655 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55656 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55657 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55658 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55659 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55660 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55661 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55662 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55663 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55664 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55665 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55666 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55667 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55668 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55669 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55670 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55671 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55672 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55673 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55674 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55675 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55676 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55677 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55678 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55679 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55680 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55681 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55682 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55683 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55684 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55685 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55686 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55687 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55688 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55689 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55690 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55691 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55692 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55693 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55694 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55695 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55696 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55697 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55698 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55699 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55700 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55701 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55702 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55703 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55704 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55705 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55706 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55707 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55708 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55709 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55710 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55711 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55712 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55713 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55714 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55715 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55716 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55717 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55718 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55719 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55720 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55721 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55722 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55723 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55724 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55725 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55726 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55727 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55728 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55729 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55730 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55731 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55732 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55733 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55734 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55735 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55736 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55737 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55738 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55739 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55740 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55741 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55742 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55743 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55744 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55745 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55746 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55747 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55748 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55749 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55750 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
55751 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
55752 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
55753 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
55754 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
55755 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
55756 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
55757 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
55758 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
55759 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
55760 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
55761 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
55762 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
55763 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
55764 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
55765 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
55766 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
55767 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
55768 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
55769 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
55770 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
55771 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
55772 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
55773 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
55774 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
55775 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
55776 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
55777 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
55778 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
55779 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
55780 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
55781 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
55782 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
55783 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
55784 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
55785 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
55786 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
55787 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
55788 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
55789 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
55790 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
55791 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
55792 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
55793 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
55794 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
55795 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
55796 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
55797 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
55798 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
55799 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
55800 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
55801 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
55802 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
55803 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
55804 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
55805 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
55806 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
55807 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
55808 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
55809 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
55810 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
55811 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
55812 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
55813 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
55814 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
55815 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
55816 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
55817 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
55818 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
55819 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
55820 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
55821 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
55822 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
55823 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
55824 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
55825 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
55826 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
55827 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
55828 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
55829 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
55830 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
55831 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
55832 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
55833 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
55834 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
55835 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
55836 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
55837 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
55838 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
55839 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
55840 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
55841 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
55842 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
55843 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
55844 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
55845 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
55846 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
55847 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
55848 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
55849 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
55850 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
55851 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
55852 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
55853 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
55854 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
55855 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
55856 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
55857 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
55858 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
55859 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
55860 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
55861 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
55862 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
55863 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
55864 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
55865 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
55866 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
55867 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
55868 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
55869 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
55870 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
55871 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
55872 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
55873 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
55874 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
55875 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
55876 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
55877 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
55878 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
55879 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
55880 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
55881 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
55882 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
55883 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
55884 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
55885 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
55886 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
55887 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
55888 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
55889 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
55890 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
55891 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
55892 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
55893 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
55894 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
55895 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
55896 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
55897 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
55898 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
55899 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
55900 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
55901 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
55902 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
55903 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
55904 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
55905 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
55906 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
55907 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
55908 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
55909 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
55910 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
55911 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
55912 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
55913 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
55914 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
55915 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
55916 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
55917 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
55918 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
55919 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
55920 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
55921 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
55922 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
55923 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
55924 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
55925 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
55926 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
55927 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
55928 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
55929 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
55930 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
55931 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
55932 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
55933 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
55934 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
55935 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
55936 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
55937 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
55938 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
55939 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
55940 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
55941 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
55942 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
55943 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
55944 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
55945 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
55946 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
55947 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
55948 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
55949 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
55950 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
55951 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
55952 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
55953 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
55954 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
55955 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
55956 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
55957 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
55958 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
55959 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
55960 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
55961 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
55962 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
55963 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
55964 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
55965 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
55966 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
55967 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
55968 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
55969 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
55970 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
55971 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
55972 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
55973 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
55974 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
55975 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
55976 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
55977 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
55978 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
55979 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
55980 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
55981 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
55982 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
55983 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
55984 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
55985 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
55986 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
55987 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
55988 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
55989 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
55990 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
55991 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
55992 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
55993
55994 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
55995
55996
55997 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
55998
55999 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56000 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56001 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56002 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56003 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56004 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56005 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56006 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56007 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56008 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56009 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56010 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56011 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56012 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56013 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56014 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56015 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56016 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56017 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56018 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56019 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56020 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56021 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56022 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56023 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56024 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56025 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56026 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56027 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56028 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56029 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56030 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56031 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56032 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56033 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56034 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56035 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56036 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56037 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56038 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56039 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56040 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56041 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56042 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56043 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56044 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56045 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56046 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56047 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56048 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56049 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56050 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56051 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56052 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56053 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56054 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56055 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56056 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56057 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56058 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56059 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56060 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56061 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56062 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56063 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56064 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56065 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56066 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56067 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56068 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56069 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56070 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56071 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56072 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56073 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56074 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56075 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56076 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56077 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56078 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56079 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56080 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56081 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56082 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56083 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56084 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56085 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56086 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56087 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56088 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56089 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56090 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56091 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56092 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56093 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56094 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56095 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56096 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56097 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56098 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56099 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56100 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56101 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56102 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56103 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56104 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56105 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56106 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56107 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56108 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56109 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56110 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56111 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56112 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56113 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
56114 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56115 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56116 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56117 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56118 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56119 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56120 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56121 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56122 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56123 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56124 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56125 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56126 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56127 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56128 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56129 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56130 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56131 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56132 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56133 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56134 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56135 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56136 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56137 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56138 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56139 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56140 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56141 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56142 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56143 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56144 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56145 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56146 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56147 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56148 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56149 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56150 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56151 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56152 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56153 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56154 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56155 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56156 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56157 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56158 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56159 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56160 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56161 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56162 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56163 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56164 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56165 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56166 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56167 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56168 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56169 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56170 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56171 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56172 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56173 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56174 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56175 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56176 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56177 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56178 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56179 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56180 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56181 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56182 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56183 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56184 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56185 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56186 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56187 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56188 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56189 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56190 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56191 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56192 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56193 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56194 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56195 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56196 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56197 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56198 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56199 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56200 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56201 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56202 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56203
56204 // Initialize threading, some globals and such
56205 __wxPyPreStart(d);
56206
56207
56208 // Although these are defined in __version__ they need to be here too so
56209 // that an assert can be done to ensure that the wxPython and the wxWindows
56210 // versions match.
56211 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56212 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56213 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56214
56215 }
56216
wxWidgets (Impactor)